Transcription
1. Introduction: Hey, merci d'
être passé et bienvenue
au cours d'authentification
et d'autorisation Dotnet six. Je m'appelle Patrick Guards. Vous me connaissez peut-être déjà depuis ma chaîne YouTube où
j'ai surtout parlé développement
web avec dotnet et blazer et Angular
React et ainsi de suite. Donc, si vous ne connaissez pas déjà
la chaîne, vous voudrez
peut-être y jeter un coup d'œil. Merci beaucoup
d'avoir réfléchi, mais bien sûr, vous pouvez également
rester avec moi ici car dans ce cours d'
autorisation d'authentification, vous apprendrez comment créer
un utilisateur dans une base de données. Donc, l'enregistrement d'un utilisateur, journalisation de cet utilisateur demande la largeur, nom d'utilisateur et le mot de passe. Nous utiliserons un hachage de mot et le mot de passe pour cela. Ensuite, nous créons
un jeton Web JSON. C'est donc un élément important du processus d'authentification. De plus, en plus
du jeton Web JSON, nous utiliserons des jetons d'actualisation. Donc, si le
jeton Web JSON a expiré, nous allons voir
le jeton d'actualisation et
comment actualiser le jeton Web JSON
avec ce jeton d'actualisation. Et en plus de cela, bien sûr,
nous allons regarder la route. Il s'agit donc de n, la
partie d'autorisation dans laquelle nous utiliserons une revendication pour donner
des rôles spécifiques à un utilisateur et uniquement
avec un rôle spécifique, l'utilisateur peut appeler
certains points de terminaison. C'est donc ce que
nous allons faire. Vous êtes maintenant
viré et souhaitez participer à ce cours parce qu'
il n'est pas si long et dans ce
court laps de temps, vous pourrez faire
tout cela avec dotnet six. J'espère donc vous voir
dans la première leçon.
2. Aperçu du cours: Merci beaucoup d'avoir
rejoint ce cours maintenant, tout d'abord, un aperçu très rapide.
Que vas-tu faire ? Il s'agit de jetons Web JSON, jetons d'
actualisation et de rôles. Et bien sûr, la première
chose
dont nous avons besoin pour cela, c'est nos utilisateurs. Nous allons donc commencer par créer un modèle utilisateur
et également un DTO utilisateur, c'est-à-dire un
objet de transfert de données afin
d'envoyer un nom d'utilisateur et un mot de passe en texte
brut à l'API Web. Et à partir de là, nous
créerons le hachage de mot de passe
et le mot de passe salé. Et puis nous le ferons,
c'est important. Nous stockerons l'utilisateur complet
avec le nom d'utilisateur et le mot de passe ID, hachage et le mot de passe sel dans la base de données. Très bien, c'est ce que
nous allons faire en premier. Et après cela, nous
essayerions de verrouiller cet utilisateur. Encore une fois, nous utiliserons
le même DTO utilisateur, enverrons le nom d'utilisateur et le mot de
passe pour le journal n. nous
enverrons le nom d'utilisateur et le mot de
passe pour le journal n.
C'est la même chose que celle utilisée
pour l'enregistrement. Ce DTO sera ensuite
utilisé dans notre API Web. Nous créerons à nouveau le hachage
de mot de passe à l'aide du sel qui est ensuite
stocké dans la base de données. C'est donc ce que vous allez
faire et lorsque tout
est correct, le nom d'utilisateur et
le mot de passe correspondent
au personnel que nous avons vu ou
stocké dans la base de données. Ensuite, nous créerons
le jeton Web JSON. C'est donc la première étape. Après cela, nous sommes également en mesure
de créer des jetons de rafraîchissement. Et après cela, nous examinerons
également les rôles. Alors maintenant les
jetons Web utilisateur et JSON, commençons.
3. Créer le projet: Nous sommes ici avec Visual Studio 2022 et
créons maintenant un nouveau projet. J'ai supposé que vous avez déjà installé le Dotnet six STK. C'est donc bien sûr des
exigences. Donc, s'il vous plaît, si vous
n'avez pas déjà
recherché les kits SDK Dotnet avec
Google par exemple, puis
installez simplement cette chose. Et après cela, ouvrez
Visual Studio 2022, bien
sûr, c'est
aussi une exigence, mais je pense que vous avez
déjà tout cela. Ensuite, nous créons un projet ASP
NET Core Web API. Donc, juste un backend dans
cette classe ici. Et maintenant appelons cette chose API Web
d'authentification. Par exemple,
l'API Web d'authentification, c' est
à vous de choisir. C'est très bien. Encore une fois, dotnet six est le
framework que nous voulons utiliser. Nous n'avons besoin d'aucun type
d'authentification. Nous le faisons manuellement cette fois-ci. Nous configurons pour HTTPS,
c'est bon. Nous utilisons un contrôleur, donc nous
n'utilisons pas d'API minimales ici. Et nous activons la prise en charge des API ouvertes. Cela signifie que
nous pouvons utiliser swagger pour tester notre API. Alors créons
notre projet. Très bien, et comme vous pouvez le constater, nous avons déjà
ici
notre exemple de projet avec les prévisions météorologiques. Je suppose que vous
connaissez déjà ce genre de choses. Ce n'est donc pas pour le débutant
absolu ici. Je n'irai donc pas en profondeur ici concernant le projet d'
exemple. Nous commencerons tout de suite. La première chose
dont nous avons besoin, c'est qu'après la création de
ce projet, nous ajoutons quelques modèles.
4. Ajouter le modèle utilisateur: La première chose
dont nous avons besoin, c'est le modèle utilisateur. Pour ça. Créons d'
abord un nouveau dossier et appelons ces modèles. Maintenant, ici, nous ajoutons une nouvelle classe
et ce sera l'utilisateur, et ce sera également l'entité qui
stockera dans la base de données. Donnons donc cette chose à
D. Ce que je fais ici, c' est
taper prop pour la propriété, appuyer deux fois sur Tab, puis nous pouvons déjà entrer la propriété suivante, qui est le nom d'utilisateur. Et il s'agit d'une
chaîne vide par défaut. Et autre chose suivante,
c' est déjà
intéressant et important. Nous stockons un hachage de mot de passe, le mot de passe salé
dans la base de données. donc pas ce qui est suggéré
ici par le code IntelliJ. Nous stockerons un tableau d'octets, qui est le hachage du mot de passe. Et nous pouvons en fait donner à cela une valeur par défaut
comme le tableau d'octets 32. C'est bon. Mais ce qui est très important pour nous
pourrait en fait aussi maintenant. Mais de cette façon, nous ne voyons pas
ces lignes vertes. Alors, restez avec moi ici. Je pense que c'est très bien. Maintenant, c'est le sel. Et encore une fois, donnons à cette
chose un tableau d'octets par défaut. Très bien, il s'
agit donc de notre modèle utilisateur, et dans quelques minutes nous le
stockerons également dans la base de données. Mais nous allons d'abord le faire, c' est-à-dire enregistrer
un utilisateur sans base de données et seulement lorsque nous l'avons implémenté et que vous avez
déjà eu l'idée du fonctionnement de l'
enregistrement et de la création
d'un hachage de mot de passe. Ensuite, nous le stockerons
également dans la base de données. Il s'agit donc de notre modèle d'utilisateur et nous avons déjà besoin d'
une autre chose. Et ce serait l'objet de
transfert de données pour l'utilisateur, ce qui signifie que nous avons besoin d'un autre objet, un autre modèle dans lequel nous
pouvons transférer le nom d'utilisateur puis le mot de passe réel en texte
brut vers l'API Web. Nous allons donc ajouter un autre modèle ici. Nous ajoutons une classe
, puis nous disons l'utilisateur D TO. Bien sûr, vous pouvez également
utiliser différents dossiers ici. Vous pouvez appeler ces
entités de dossier, par exemple, et simplement placer l'utilisateur ici
car il s'agit d'une entité qui est également
représentée dans la base de données. Ensuite, un autre
dossier pour le DTO est celui des objets de transfert de données et
il suffit d'ajouter le DTO utilisateur ici. C'est à vous de décider. Le problème avec un utilisateur DTO
maintenant, c'est que nous utiliserons cette chose pour
enregistrer un utilisateur et également enregistrer l'utilisateur n.
Vous vous demandez peut-être pourquoi ne pas utiliser un objet de
demande de registre d'utilisateur et l'utilisateur objet de demande de connexion par
exemple. Eh bien, nous pouvons utiliser cette DTO
ici pour les deux cas d'utilisation. Il suffit donc d'entrer la
première propriété qui est une chaîne en fait
le nom d'utilisateur. Et par défaut, l'envoyer
à la chaîne vide. Et maintenant, en fait, le mot de passe. Donc cette fois,
c'est correct, OK,
maintenant ce sont tous les
modèles dont nous avons besoin pour le moment, la prochaine étape est déjà ajouter le
contrôleur d'authentification. Alors, faisons-le ensuite.
5. Ajouter le contrôleur d'authentification: Le
contrôleur d'authentification, nous cliquons avec
le bouton droit sur le dossier Controllers
, puis Controller simplement la
première entrée de menu ici. Ensuite, nous recevons
quelques suggestions. Nous ne voulons pas utiliser
de contrôleur MVC, nous voulons utiliser un contrôleur
API. Vous le voyez ici, nous en
avons un vide, nous avons déjà une largeur, des actions de
lecture et d'écriture. Cela fournira alors code
généré pour
toutes les opérations grossières,
création, lecture,
mise à jour et suppression. Et nous avons déjà obtenu ce truc ici en utilisant
Entity Framework. Beaucoup de code déjà
généré pour nous. À mon avis, il est toujours
préférable ou presque toujours préférable d'en utiliser
un vide, car
vous pouvez ensuite construire n'importe quoi
à partir de zéro. Vous avez tout le
contrôle et vous savez ce qui est réellement fait ici. Et vous pouvez, Eh bien,
vous avez le plus de
contrôle sur votre code à des fins
d'apprentissage. Bien sûr, un vide
est également très soigné. Créons donc un contrôleur d'API
vide et nous appelons simplement cette chose maintenant hors contrôleur
pour l'authentification. Ici. Maintenant, ce que je
veux déjà faire, c'est écrire la méthode d'enregistrement de l'utilisateur. Donc, ce que nous pouvons faire, c'est
simplement une tâche asynchrone publique, alors résultat réel, le résultat réel serait
suffisant, est totalement suffisant. Mais si vous voulez voir
les modèles réels
représentés dans l'interface utilisateur de Silva, vous devez utiliser
un résultat réel
, puis définir le modèle
exact renvoyé ici. Et maintenant, supportez moi, nous allons renvoyer l'utilisateur
avec un hachage de mot de passe. Et maintenant, en production, bien
sûr, vous ne
feriez pas quelque chose comme ça. Vous envoyez simplement le
texte, peut-être un sac ou simplement un code d'état de
succès 200, d'accord. où l'application, l'avant et puis sait que
tout s'est bien passé. Mais dans notre cas,
pour voir pour l'instant ce
qui se passe réellement ici, nous retournerons l'utilisateur. Ce n'est vraiment qu'
à des fins d'apprentissage. Et nous en avons besoin d'une autre, nous avons besoin d'une référence d'utilisation ici, en utilisant une directive, en utilisant l'
authentification, les modèles d'API Web. Et puisque je suis un
codeur paresseux ou que je
veux juste utiliser les nouveaux
trucs de C-sharp ten. Utilisons une utilisation globale
ici dans le programme CS. Maintenant, nous le savons déjà, connaissons également le modèle ici dans cette classe dans le contrôleur de la
Terre, bien que nous n'ayons aucune
modification de référence ici, n'est-ce pas sympa ? Appelons maintenant cet utilisateur du
registre. Ici, c'est maintenant l'utilisateur DDoS que
nous demandons des objets ici. Nous pouvons maintenant
créer un nouvel utilisateur. Encore une fois, c'est juste pour l'instant. Dans quelques
minutes, nous allons stocker cette chose dans la base de données. Mais pour l'instant,
voyons simplement à quoi cela ressemble lorsque nous créons un nouvel utilisateur
avec le nom d'utilisateur donné. Et puis nous revenons, OK, donc le code d'état 200
avec l'utilisateur ici. Très bien, c'est donc notre méthode. Et maintenant, la dernière chose importante, c'est
que nous avons besoin d'une méthode de requête HTTP. Et pour cela, nous utiliserons la méthode post identifie une action qui prend en charge
la méthode HTTP post. Maintenant, sauvegardons cela
et
exécutons déjà et testons cela un peu.
6. Premier test avec SwaggerUI: Voici donc notre application ou l' interface utilisateur
Swagger afin que nous
puissions tester notre nouvelle API. Et maintenant, utilisons simplement cette méthode
off ici, vous la
voyez déjà. L'utilisateur DTL. La demande est donc un
nom d'utilisateur et un mot de passe et nous attendons un
objet utilisateur, c'est le seul. Et nous voyons également nos modèles ici. Il s'agit donc de l'utilisateur et
de l'utilisateur D TO. Très bien, donc nous allons
juste écrire. On peut peut-être faire
quelque chose comme Iron Man, mot de passe, poivre, appuyer sur Execute. Et que voyons-nous ? L'ID n'est pas égal à 0. C'est exact. Lorsque nous utilisons une base de données, cela sera différent. La base de données fera
le travail pour nous ici et ajoutera un ID 123, etc. Le nom d'utilisateur est resté. Nous voyons donc que cela a
vraiment fonctionné. Et ces
valeurs de hachage ici sont
les tableaux d'
octets initialisés. Il n'a donc rien avec ce mot de passe
ici, bien sûr, mais nous voyons que notre
API fonctionne déjà. Maintenant, la prochaine étape que j'
aimerais faire est que nous voulons utiliser l' injection de
dépendances,
car lorsque nous avons toute notre logique
ici dans le contrôleur, il s'agit d'un contrôleur PHET qui n'est pas la meilleure pratique. Changeons donc un
peu cela et la prochaine leçon. Et nous ajoutons le service d'authentification,
puis nous y mettons la logique.
7. Ajouter le service d'authentification: Maintenant, pour le service d'authentification, recréez un nouveau dossier
et appelez ces services. Et un autre dossier
a également appelé ce service hors service. heure actuelle, nous créons
une interface pour cette interface appelée I de service et aussi une classe d' implémentation appelée
ce truc de service. Et bien sûr, nous mettons en œuvre
l'IA de service ici. Et lorsque vous cliquez sur Enregistrer, oui, nous voulons reconstruire et
appliquer toutes nos modifications. Et maintenant pour être sûr que l'injection
de dépendances fonctionnera, nous devons enregistrer ce
service ici dans le programme CS. Nous écrivons des
services de construction et partons. Il s'agit d'un service d'étendue du type spécifié dans le type de service pour la collection
de services spécifique. Très bien, et maintenant nous avons écarté notre
attention sur le service ici. Je dois l'écrire correctement pour
servir ça hors service. Et bien sûr, nous ajoutons la directive d'
utilisation et
ajoutons également le mot-clé global afin que
notre contrôleur sache également où
trouver ce service en une minute le mot-clé global afin que
notre contrôleur sache également où
trouver ce service en une minute. Maintenant, cette chose est enregistrée. Cela signifie que nous pouvons l'
injecter dans le
contrôleur terrestre en une minute. Mais tout d'abord, mettons
notre méthode de registre ici dans l'interface. Utilisateur de la tâche. Appelez à nouveau cet utilisateur
de registre auprès de l'utilisateur DTO et
appelez cela simplement des demandes. Maintenant, enregistrez ça. Et bien sûr, je l'ai
enregistré trop tôt car il n'est pas encore
mis en œuvre. Mais avec la période de contrôle, nous pouvons implémenter l'interface
au mot-clé async. Maintenant, en substance, nous pouvons copier cette ligne ici sur
le contrôleur ici, et simplement renvoyer cet utilisateur. Et nous avons fini de déplacer la logique du contrôleur
vers le service auteur. Et la prochaine chose, c'
est que nous devons injecter ce service et
tout assembler. Alors, faisons-le ensuite.
8. Injectez le service (Injection de dépendance): Pour injecter cette chose, nous allons
au contrôleur Off et ajoutons abord
un constructeur ici avec CTE OR
, puis appuyez deux fois sur Tab. Et ici maintenant, nous
disons que je suis du service, appelle ce truc hors service
et aussi avec période de contrôle. Maintenant, nous pouvons créer et
attribuer ce champ que ce service est disponible partout dans ce
contrôleur maintenant, et j'aimerais ajouter
ce trait de soulignement ici. Et maintenant, ici,
dans cette méthode, nous disons, par exemple, que réponse
virale pondére les demandes des
utilisateurs enregistrés au
service. Vous voyez ça ?
Nous avons donc maintenant cette logique, déplacé vers le service auteur, et le contrôleur transmet uniquement la demande au service
et renvoie les résultats. Dans notre cas, il s'agirait
alors de la réponse. Maintenant, nous pouvons tout sauvegarder, le
tester à nouveau et le résultat
devrait être exactement le même. Nous y voilà. Une fois encore. C'est notre point final. Nous essayons
encore ça avec Iron Man. Et ce mot de passe
ici est exécuté. Et c'est exactement la même chose que
nous avons déjà vu
quand nous ne le sommes pas, pas utiliser l'injection de dépendance. Mais ce qui
est génial encore une fois, c'est que vous pouvez injecter le service et la logique où vous le souhaitez dans
votre application. Et c'est certainement
une meilleure pratique. Très bien, c'est donc le
premier code de la plaque de chaudière. Et maintenant, la prochaine chose est de créer
le hachage
du mot de passe. Alors, faisons-le ensuite.
9. GitHub Repo: vite avant écrire la méthode pour
créer le hachage de mot de passe, jusqu'à présent nous avons déjà
fait quelques trucs, donc je pense qu'il est bon de le pousser
dans un référentiel Git. Je l'ai fait. Et vous pouvez maintenant obtenir
le code ici. Donc, si vous ne
voulez pas l'écrire vous-même,
c' est le bon moment pour récupérer le code ici depuis
mon dépôt GitHub. Voir l'URL ici, barre oblique
github.com Patrick a obtenu une API Web d'authentification oblique. C'est donc ici que vous
trouverez le
code source complet de cette classe. C'est juste pour un petit indice. Encore une fois, si vous ne
voulez pas écrire le code vous-même, bien que je le
recommande vraiment, car c'est la
meilleure façon d'apprendre. Vous pouvez obtenir le code ici
ou si vous rencontrez des problèmes. Encore une fois, vous pouvez
également obtenir le code, bien
sûr maintenant sur GitHub.
10. Créer le mot de passe Hash: Ensuite, je créerai
le hachage du mot de passe. Ce que nous faisons maintenant,
c'est de revenir
au service d'authentification et d'
écrire des méthodes simples. C'est donc un vide privé et nous appelons cela créer un hachage
de mot de passe. Ce truc obtient maintenant un mot de passe. Il s'agit donc du mot de passe et des texts en simple, puis de
deux paramètres de sortie, et ce serait le tableau d'octets de hachage de mot de
passe et le mot de passe salé mord hachage de mot de
passe et aussi les
octets, les sels de mot de passe. Comment faire ça maintenant ? En fait, ce n'est pas grand-chose. Nous créons d'abord une instance
d'algorithme de cryptographie
et, dans notre cas, nous
utiliserons HMac 512. Encore une fois, nous avons besoin d'une
directive d'
utilisation, utilisant la
cryptographie de sécurité des systèmes. Et ici maintenant, lorsque nous aurons ce cas, nous avons déjà un
mot de passe sel et je reviendrai au
mot de passe sel dans une seconde. Donc ce serait HMac
et ensuite la clé, c'est notre sel. Maintenant, pour obtenir le hachage du mot de passe, nous disons calculer le hachage, puis textes
système codant UTF-8 obtiennent des octets puis le mot de passe. Maintenant, ce qui se passe réellement ici avec la méthode de hachage
de création de mot de passe, nous générons un sel. Maintenant, c'est comme il est indiqué ici, une clé utilisée dans
le calcul HMac. Et lorsque vous combinez le
sel avec le mot de passe, vous obtenez un hachage de
mot de passe différent, bien que vous utilisiez
le même mot de passe. Maintenant, pour mieux voir tout
le processus ici, je
dirais qu'il suffit de tester cela. Utilisons déjà la méthode de
hachage de création de mot de passe. Et puis vous
verrez que lorsque nous utiliserons le mot de passe poivre
plusieurs fois, nous obtiendrons une valeur de hachage
de mot de passe différente. C'est à cause du sel. Mais s'il
utilisait toujours le même sel, le hachage du mot de passe
serait le même. Et le problème, c'est
qu'un jour, gens
très intelligents vont craquer les
algorithmes de cryptographie et
ensuite voir un hachage de mot de passe. Et à partir du hachage du mot de passe, ils peuvent accéder au mot de passe texte de l'
avion. Mais cela ne
se fait pas avec du sel. qui signifie que s'ils
ne connaissent pas le sel, ils ne peuvent pas obtenir le
mot de passe, le vrai mot de passe. Très bien,
essayons simplement ça et alors vous
verrez ce que je veux dire par là. Donc, d'abord, lorsque nous
enregistrons un utilisateur, nous disons que nous créons
le hachage du mot de passe. Donc, créez un hachage de mot de passe. Ce truc obtient
le mot de passe ici. Et maintenant, le hachage du mot de passe, le sel de mot de passe
qui est renvoyé. Sens. Ici. Nous obtenons cette chose et
aussi les sels de mot de passe. Très bien, maintenant, nous avons
notre valeur de hasch et de sel. Et maintenant, pour l'utilisateur,
ce que nous faisons, c'est non
seulement de définir le nom d'utilisateur, mais aussi de définir le hachage du mot de passe en
hachage de mot de passe. Ici, nous avons défini le mot de passe
sel sur les sels de mot , d'
accord, puis nous
retournons l'utilisateur. Essayons donc maintenant. Redémarrez l'application. Encore une fois quand nous utilisons Ironman. Et que voyons-nous maintenant ? Nous voyons cette chaîne folle ici, ou par un tableau pour Bx et ainsi de suite. Maintenant, quand j'essaie à nouveau, différent et
regardent à nouveau différent. Faisons cela
un peu différemment. Disons donc que nous donnons cet algorithme de
cryptographie déjà assaut comme un
nouveau tableau d'octets 32. Ce sera donc la
clé qui sera utilisée ici. Très bien, voyez ça ici. Il y a une surcharge
, celle,
l' instance sans
clé ni sel, et l'instance
avec ce sel maintenant, ce qui signifie que maintenant
dans cette méthode de hachage de calcul, l'algorithme utilisera ce sel ici chaque
fois que nous faisons cela. Enregistrons-nous
à nouveau et redémarrons l'application juste pour être sûr. Nous essayons encore une fois. Essayez-le. L'homme. Pas de poivre. Nous cliquons sur Execute for M MPH et exécutons à nouveau
pour MPH et ainsi de suite. À chaque fois. La même chose que vous voyez ici
est la raison pour laquelle nous avons besoin d'un sel. Le sel est le même et le mot de
passe en texte brut est le même, puis nous obtenons la même
valeur de hachage à chaque fois. Il en va de même
si vous n'utilisez pas de sel du tout, ce qui
signifie qu'un mot de
passe spécifique
donne toujours la même valeur de hachage et vice versa et essence. Et maintenant, lorsque nous supprimons
cette nouvelle clé et que nous
utilisons réellement une nouvelle clé
générée aléatoirement comme sel, nous obtenons un mot de passe
différent, un hachage de mot de passe différent. Chaque fois que nous
utilisons cet algorithme. Très bien, voyez ça ici. C'est pourquoi nous utilisons du sel. J'espère que vous avez eu l'idée. C'est ainsi que nous créons
un hachage de mot de passe. Et maintenant, avant de continuer à connecter l'utilisateur, puis à
créer le jeton Web JSON. Je dirais que nous ajoutons notre base de données et que nous
stockons l'utilisateur avec le hachage du mot de passe
et le sel, etc. dans cette base de données. Nous allons le faire ensuite.
11. Ajouter le noyau DataContext & Entity Framework: Très bien, nous voulons donc
utiliser Entity Framework Core ici et aussi une base de données lite
suite. Cette fois, j'utilise
différentes bases de données tout au long de mes cours
et de mes didacticiels. Cette fois-ci, utilisons une base de données
SQL Light. C'est multiplateforme et
assez simple à créer. La première chose maintenant,
avant de pouvoir utiliser cette base de données, c'est que nous avons
besoin d'un contexte de données. Encore une fois, nous créons un nouveau
dossier appelé ces données. Ici. Nous ajoutons maintenant une nouvelle classe et nous appelons ce contexte de données de
classe. Et cette chose utilise ici
la classe de contextes DB. On ne le sait pas ici. Par conséquent, avec la période de contrôle, nous recevons quelques suggestions. Et nous voulons utiliser cette
chose ici, installer le package Microsoft Entity Framework Core, trouver et installer la dernière
version déjà effectuée. Maintenant, c'est fini. Et encore une fois, nous pouvons utiliser une directive
globale sur l' ici parce que nous avons besoin de cette
chose à plusieurs endroits. Faisons donc ça comme ça. Et maintenant, nous avons le contexte
DB ici. Avec ces contextes DB,
nous pouvons désormais accéder aux
utilisateurs à partir de notre base de données. Et vous le voyez ici. Il indique qu'une
instance de contexte DB représente une session avec la base de données et peut être utilisée pour interroger
et enregistrer des instances, des
instances de vos entités. Le contexte DB est une combinaison de l'unité de travail et du modèle de
référentiel. En ce qui concerne le modèle de
référentiel, il est similaire à notre service
Auth, car nous pouvons
désormais injecter ce contexte, par
exemple dans notre
service Auth, puis
accéder
à nouveau aux utilisateurs de la base de données. Mais nous devons encore faire quelque
chose pour pouvoir le faire. Enfin, la première chose
est le constructeur. Encore une fois avec CD OU nous sommes
encore notre constructeur. L'argument ici est désormais
les options de contexte DB. Ce truc ici avec notre classe. Et nous appelons cela Options. Et nous devons également
appeler le
constructeur de base avec des options de base. C'est donc maintenant le
constructeur dont nous avons besoin. Et la dernière chose pour
pouvoir ajouter les utilisateurs ou pour être plus précis pour ajouter la table des utilisateurs dans la base de données, nous avons besoin d'une propriété ici. Et c'est de type db
set avec classe utilisateur. Nous appelons cela des utilisateurs et ce sera le nom de notre table. Donc, généralement, vous devez simplement pluraliser le nom
de cette entité. Les utilisateurs seraient donc
totalement suffisants. Et je pense que c'est un
bon nom pour cette table. C'est ce que nous devons
faire pour ajouter ce tableau. Et si vous n'aimez pas cette ligne
verte,
vous pouvez déjà dire qu'il s'agit
d'un ensemble d'utilisateurs comme celui-ci, et vous ne recevez plus
d'avertissement. Bon, gardons ça. Et maintenant, l'étape suivante consiste à utiliser les premières migrations de
code
pour créer notre base de données. Mais avant de pouvoir le faire,
nous devons bien sûr installer les outils Entity Framework Core. Alors, faisons-le ensuite.
12. Installer les outils de base EF: Installation des outils Entity
Framework Core. Nous avons ouvert la console du
gestionnaire de paquets. Vous pouvez également ouvrir cette chose ici sous d'autres fenêtres ,
puis vous obtenez la console
Package Manager. Et il devrait y avoir
un raccourci pour cela. Et ici, la première
chose que nous
devons faire est d'être dans le
bon répertoire. Nous devons donc accéder à notre
répertoire d'API Web d'authentification. Nous y sommes. Ensuite, nous devons arrêter
l'application. Il suffit donc de fermer le terminal ici. Et maintenant, nous pouvons
installer les outils EF Core,
puis la migration. Assurez-vous donc d'arrêter
l'application car sinon nous ne sommes pas en mesure d'
exécuter les premières migrations de code, mais d'abord les outils nécessaires. Nous disons dotnet new
install puis dash, dash global,
puis dotnet dash EF. Maintenant, dans mon cas, je l'
ai déjà installé, alors laissez-moi le
désinstaller très rapidement. Nous pouvons donc le faire ensemble ici. Désinstallez Dotnet ef. Vous le voyez ici, version 6.3. Et maintenant, si j'exécute à nouveau la commande d'
installation, j'obtiens la version 604. Et avec Dotnet E F,
on peut vérifier. Et il existe les outils de ligne de commande
Entity Framework Core dotnet. Donc cette chose j'ai
été installée et ensuite nous utilisons le code d'
abord, les migrations.
13. Utiliser les premières migrations de code: Nous sommes dans le bon répertoire. Nous avons installé les outils de
ligne de commande,
nous avons installé le package
NuGet Energy Framework, mais il y a deux autres
packages NuGet que nous devons installer. Et c'est le package de
conception et le paquet SQL lite de l'
énergie encadrent un noyau. Maintenant, le design, vous le
verrez dans une minute. Laissez-moi juste ouvrir ça. Cliquez donc avec le bouton droit sur le projet
Gérer les packages NuGet. Ensuite, nous disons simplement design et je pense que
nous avons déjà compris cela. Assurez-vous ensuite d'utiliser
l'onglet de navigation ici. C'est là que Microsoft Entity Framework Core Design a partagé les composants de temps de
conception pour la
saisie à partir d'un outil principal. C'est donc important pour nous. Cliquez sur OK, j'accepte
puis Entity Framework
Core SQL light. Ainsi, lorsque vous souhaitez utiliser
une base de données SQL Light, vous devez installer ce fournisseur de base de données SQL
pour Entity Framework Core. Si vous souhaitez utiliser SQL Server, il s'agit d'une essence uniquement
Entity Framework, Core dot SQL Server, etc. Alors, installez
cette chose maintenant. D'accord, j'accepte que nous ayons nos paquets NuGet pour que
nous puissions fermer ça. La prochaine étape consiste maintenant à
enregistrer les contextes de notre base de données. Encore une fois au programme CS. En bas, nous disons créer
des services, puis ajouter des contextes
D B avec la classe de contexte de
données. Et cette chose. Maintenant, nous devons d'abord en ajouter
un autre en utilisant l'érection ici. Encore une fois, ajoutons
le mot-clé global. Nous avons donc maintenant
notre contexte de données, et cela a une option. Disons des options. Options. Nous voulons dire que
nous voulons utiliser SQL Light et que nous pouvons ajouter
une chaîne de connexion ici. Généralement, vous devez maintenant stocker
la chaîne de connexion, par
exemple, dans le fichier JSON des paramètres de
l'application. Vous pouvez toujours le faire ou la manière rapide et sale car s'agit que d'une base de données SQL
Light, manière
rapide et sale consiste à entrer la chaîne ici et la chaîne de
connexion pour
une base de données sqlite. Permettez-moi de mettre cela dans une nouvelle ligne, c'est simplement une source de données,
puis par exemple, de point db. Donc, le type de fichier est alors DB
et il suffit d'annuler cela. C'est à vous de choisir. Vous pouvez utiliser n'importe quel nom de votre choix. C'est ainsi que nous
enregistrons le contexte DB. Avec cela, nous pouvons utiliser
la première migration de code pour créer notre base de données
avec la table des utilisateurs. Nous allons donc à nouveau dans la console Package
Manager, assurez-vous d'être placé dans
notre répertoire de projets. Donc, l'API Web
d'authentification, l'API Web d'authentification,
c'est dans ce cas. Et puis on peut
juste dire Dotnet ef. Jetons un coup d'œil rapidement. Nous avons trois commandes, base de données, contexte
et migrations. Et pour ajouter une migration, eh bien, nous utilisons des migrations, donc des migrations Dotnet EF
puis des ajouts, puis
appelons simplement cette initiale. Il est en construction, mais
il a réussi et c'est
déjà fait. Ce que nous obtenons maintenant, c'est un dossier
Migrations ici. Et ici, vous verrez également ce qui se
passera lorsque nous
effectuerons cette migration. Nous allons créer une table, nous
utiliser avec un identifiant défini
pour incrémenter automatiquement. Nous avons donc l'
identifiant 123 et ainsi de suite obtenu
automatiquement
le nom d'utilisateur sous forme chaîne ou de type texte. Et les tableaux d'octets
seront ensuite utilisés avec le type blob. Et nous avons déjà
une clé primaire ici. Et si je supprime cette
migration ou ce rôle, le rôle, cette banque de migration, alors nous laissons tomber ce tableau. Et maintenant, nous n'avons pas encore
la base de données, n'est-ce pas ? Donc, ce
qui se passe maintenant lorsque nous disons que mise à jour de la base de données
dotnet EF
ne consiste pas seulement à la mettre à jour, mais aussi à créer
cette base de données. Ok, donc vous voyez ici
toutes les commandes, mais cela a réussi et il
y a maintenant une table de création. Ce n'est que pour Energy
Framework, le système migratoire. Et aussi où est-il
ici les utilisateurs de la table. C'est fait. Et ici, nous voyons ce fichier off DB et sommes en
mesure d'ouvrir ce
fichier et d'y jeter un coup d'œil. Nous téléchargeons une autre chose et ce serait
le navigateur DB,
le navigateur de base de données
pour la ligne SQL. Alors, faisons-le ensuite.
14. Ouvrez la base de données avec le navigateur DB pour SQLite: Et c'est la chose
dont vous avez besoin pour transférer Google TB navigateur pour SQL Lite
ou aller sur SQL browser.org. C'est à quoi ça ressemble. Il suffit donc d'aller dans
Télécharger et ensuite pour votre système d'exploitation,
obtenez cette chose. Mon cas, je ne le sais
pas et j'ai installé le navigateur DB pour la suite, le programme d'installation standard
pour Windows 64 bits. Alors, s'il vous plaît
, prenez cette chose et vous devriez l'obtenir ici. C'est à quoi ça ressemble.
Et maintenant, nous sommes en mesure d'ouvrir la base de données. Nous y sommes. C'est notre dossier, c'est le dB off. Alors ouvrons ce truc. Et vous voyez ici,
nous avons la table des utilisateurs
avec ces champs. Et nous pouvons bien sûr le sélectionner ,
puis accéder à Parcourir les données. Et ici, nous
voyons que nous n'avons pas d'utilisateur. L'étape suivante consiste donc à
stocker enfin l'utilisateur lors de son enregistrement
dans la base de données. Nous allons donc le faire dans
la prochaine leçon.
15. Stocker l'utilisateur dans la base de données: Dans Visual Studio, nous
revenons au service hors service. Maintenant. Nous ajoutons d'abord un constructeur
car si vous vous en souvenez, nous voulions injecter
les contextes de données. CTO sont donc du service. Et ici, nous parlons maintenant du contexte
des données. Contexte. Encore une fois, nous créons et attribuons
le champ ainsi qu'un trait de soulignement. Nous avons maintenant nos contextes de
données et la prochaine chose est que
nous disons contextes, utilisateurs, vous le voyez déjà ici. Nous avons la table des utilisateurs, Ajouter des
nœuds User Entity Framework que vous souhaitez à l'
utilisateur, mais ce n'est pas fini. Nous devons également
enregistrer ces modifications un contexte de pondération. Enregistrer les modifications de manière asynchrone, d'accord, et c'est tout. Maintenant, lançons cette application à nouveau. Et je dirais que
nous ajoutons deux utilisateurs. Nous y voilà. Une fois encore. Nous essayons cela, par exemple,
avec Iron Man Pepper qui s'exécute. C'est le résultat. Vous
voyez maintenant que l'ID est un et lorsque nous accédons à notre navigateur, c'est le
cas, nous
actualisons les données. Iron Man est avec id1, hachage
de mot de passe,
sel de mot de passe, blobs et tout. Ajoutons-en un autre. Juste pour s'amuser. Mot de passe Batman,
peut-être qu'il s'exécute. Nous avons ID2 et la même chose ici. Très bien, donc ça marche. Enfin, l'étape suivante consiste à créer et à renvoyer
un jeton Web JSON. Alors, allons le faire ensuite.
16. Ajouter un AuthResponseDto: Il y en aura quatre. Nous pouvons réellement créer
le jeton Web JSON. Nous devons préparer quelques trucs. Une chose est que nous devons
vérifier le mot de passe lors de la connexion. Et cela vous
indique déjà que,
bien sûr , nous avons également besoin
d'une méthode de connexion. Et ensuite, la troisième
chose est que nous avons besoin d' un autre DTO pour renvoyer le jeton Web
JSON à la fin, eh bien, ce n'est pas totalement vrai
que nous avons vraiment besoin de ce DTO. Mais à la fin de cette classe, la
fin de ce cours, vous aurez la possibilité de
renvoyer un jeton Web JSON
avec un jeton d'actualisation. Et c'est juste
pour le front end. Il y a donc des données
dans cette réponse TO qui sont utiles
pour le front end. C'est donc ce que
nous allons faire. Nous créons d'abord
un autre modèle ici. Cliquez avec le bouton droit sur le dossier modèles, ajoutez une nouvelle classe, et maintenant nous appelons cette
chose de réponse d t. Maintenant, cette chose obtient
des propriétés. La première propriété, peut-être se demander pourquoi avons-nous
besoin de quelque chose comme ça ? Eh bien, j'appelle ça du succès. On peut dire que c'est un succès. Par exemple, cela
indiquera au frontal si cette demande a réussi, et nous l'utiliserons pour indiquer
au frontal, par
exemple, que le mot de passe était erroné ou que l'
utilisateur n'existe pas, ou que tout va bien. Et dans ce cas,
cet indicateur est défini sur vrai, mais nous l'
initialisons avec des défauts. Avec ces informations,
le frontal peut faire d'autres choses
avec cette propriété maintenant, qui est le message comme celui-ci. Et il s'agit par
défaut d'une chaîne vide. De plus, si
vous ne souhaitez pas renvoyer cette
réponse d'authentification dans DTO, nous pouvons également dire que le contrôleur fait n'
importe quoi avec cela. Par exemple, si nous utilisons à
nouveau le contrôleur pour transférer la demande au service et que le service renvoie cette
DTO, cet objet ici. Et nous voyons que le succès est l'indicateur de succès est défini
sur false et nous avons reçu un message comme un
mot de passe erroné, alors nous pouvons également décider de ne pas renvoyer l'objet complet. Nous pouvons simplement dire que nous renvoyons une mauvaise
demande, par exemple, ou un message non autorisé
ce que vous voulez. Vous seriez donc plus flexible
avec ce genre d'objet. Maintenant, la dernière chose pour l'
instant, enfin, le jeton. Supprimons cet espace ici. Et il s'agit également
d'une chaîne vide. abord, ok, c'est donc notre réponse de l'auteur DTO
avec un indicateur de succès, le message et le jeton. Et ensuite, nous allons écrire
une méthode pour vérifier le mot de passe avant de pouvoir
finalement implémenter la méthode de
connexion.
17. Vérifier le mot de passe: Il s'agit de vérifier le mot de passe. Nous revenons à notre
mur d'un service. Il s'agit là encore d'une méthode privée similaire à cette chose en fait. Nous pouvons donc copier et coller, au moins essayer de copier et
coller cette méthode ici. Au lieu de créer
un hachage de mot de passe, nous voulons maintenant vérifier
le hachage du mot de passe. Alors, entrons simplement vérifier ici. Encore une fois, nous recevons les
mots de passe de l'avion sous forme de chaîne. Et maintenant aussi le
hachage de mot de passe et le mot de passe salé, mais pas comme paramètres. Nous obtenons cela à partir de
la méthode de connexion. Et maintenant, ici, nous l'avons
déjà fait. Peut-être vous souvenez-vous, nous pouvons donner cet
algorithme de cryptographie, cette instance H mix sharp 512. Nous pouvons donner à cette chose
un sel et ce sel. Ensuite, nous essayons de calculer le hachage en fonction du mot de passe
donné, n'est-ce pas ? Donc maintenant, nous disons que notre valeur de hachage
calculée est cette chose avec le mot de passe donné sel
et le mot de passe donné. Après cela, nous retournons séquence de hachage
calculée égale,
puis le hachage de mot de passe. Puisqu'il s'agit de tableaux d'octets, nous devons utiliser la séquence égale. Bien sûr, nous avons changé
notre valeur de retour ici en valeur booléenne. Nous devons donc utiliser la séquence égale car il s'
agit de tableaux d'octets. Si vous
n'utilisez que les signes égaux, le hachage
calculé est égal
au hachage de mot de passe, cela ne fonctionnerait pas. Assurez-vous donc d'
utiliser la séquence égale. dit ici, détermine ce que les deux séquences sont égales
en comparant les éléments, en utilisant la
comparaison d'égalité par défaut pour leur type. Et dans notre cas, c'est
la morsure et le type. Par conséquent, un octet par octet, cela sera comparé
dans cette méthode. Nous savons ensuite si le
mot de passe est correct ou non. Maintenant, implémentons
la méthode de connexion suivante.
18. Mettre en œuvre la méthode de connexion: Pour la méthode de connexion, encore une fois, nous allons à l'interface
ici et nous retournons une tâche. Et maintenant, vous le voyez avec
la réponse de l'auteur. En DTO. Nous appelons cette connexion avec l'utilisateur
DTO en tant que demande. Et je reviendrai à la classe d'
implémentation. Nous pouvons
implémenter automatiquement l'interface. Et voici les méthodes. Laissez-moi juste le remonter. Allons-le ici, peut-être. C'est là. La première chose
est que nous avons besoin de l'utilisateur. Disons donc que
l'utilisateur var est maintenant Waitz. Les contextes semblent que dès que j'ai tapé l'attend, Visual Studio a édité
le mot-clé async ici. C'est plutôt sympa. N'oubliez pas que si ce n'est pas le cas, vous devez ajouter
le mot-clé async. Maintenant, les contextes et maintenant nous
pouvons accéder à nos utilisateurs. Ensuite, nous disons d'abord
ou asynchrone par défaut. Et ici, nous disons U pour l'utilisateur, où le nom d'utilisateur se produit, le nom d'utilisateur de la demande, et
si l'utilisateur est nul, nous pouvons maintenant revenir
et vous correspondez tous à l'indicateur de succès
est faux par défaut. Mais nous pouvons également
ajouter un message comme utilisateur introuvable par exemple, le
contrôleur le sait
maintenant. Et aussi si vous
retournez cet objet, le front et le
sait aussi. La prochaine étape, si
nous avons trouvé l'utilisateur, consiste à vérifier le mot de passe. Encore une fois, nous commençons par un point d'exclamation,
puis un point d'exclamation. Nous vérifions donc si le mot de passe
n'est pas correct, il n'est pas vérifié. Vous donnez le mot de passe de
demande à cette méthode Ensuite, nous avons trouvé l'utilisateur. Nous utilisons donc le hachage de mot de passe de l'utilisateur ainsi que le sel de
mot de passe de l'utilisateur. Maintenant, si ce n'est pas le cas, nous retournons à nouveau un nouveau DTO de réponse d'
authentification avec un autre message,
tel que Mauvais mot de passe. Ceci est ensuite vérifié et maintenant,
si tout est correct, nous retournons une nouvelle réponse de
l'auteur, D20. Et disons simplement que le drapeau du
succès est vrai. Pour l'instant. C'est ça. Nous n'avons pas créé de jeton. Dans cette étape,
nous voulons
d'abord vérifier si le login
avec le nom d'utilisateur
et le mot de passe fonctionne en général. Et pour pouvoir tester cela, nous avons maintenant besoin d'un autre
point final, bien sûr. Revenons donc à notre manette
hors tension. Une fois encore. Il suffit de copier
cette méthode ici. Nous appelons cela maintenant simplement se connecter. Nous appelons également ici
nos méthodes de connexion. Et maintenant, disons que si la
réponse est réussie, nous pouvons renvoyer la réponse OK. Très bien, nous retournons
la réponse complète. Sinon, nous pouvons décider, par
exemple, que nous pourrions, nous pourrions également renvoyer un
accord avec la réponse. Et dans ce
cas, le front-end doit vérifier si le succès est vrai ou faux, puis afficher
le message d'erreur ou non, nous pouvons faire autre chose. Nous pouvons dire que les mauvaises demandes
renverront une mauvaise demande et ajouteront simplement le message
en réponse. Encore une fois, comme je l'ai dit plus tôt, lorsque nous avons créé
la réponse
d'auth à cette chose,
c'est à vous de décider. Si vous pensez
avoir un front end et que vous voulez envoyer un 200 d'accord. Retour. Dans tous les cas, ça
va, ou revenez, d'accord. Et puis répondez,
alors le front doit décider quoi faire, puis faites-le comme
ça dans tous les cas. Vous n'avez donc pas besoin de
vérifier ici avec cette clause
IF si cette réponse est
réussie ou non. Et ensuite, vous pouvez simplement atteindre la réponse au premier plan
et faire tout le travail, ou si vous voulez le faire comme
ça et c'est
vraiment à vous de décider. n'y a pas de meilleure pratique
à mon avis ici. Cela dépend vraiment de l'
application que vous souhaitez créer. Mais à nos fins de test, à des fins d'apprentissage ici,
je pense que c'est correct. Nous vérifions si la
réponse est réussie. Dans ce cas, nous retournons
la chose complète. Sinon, nous voyons une mauvaise demande
juste avec le message. Et maintenant, la dernière chose que nous devons faire, vous pouvez le voir ici. Nous avons ici une méthode post et une autre méthode de
post ici. Cela ne fonctionnerait donc pas. Il s'agit de deux points
de terminaison exactement identiques avec exactement les mêmes itinéraires. Donc, juste l'API et ensuite désactivé
pour le contrôle un objectif. allons donc changer cela
et nous pouvons changer cela ici avec des publications HTTP. Ensuite, entre parenthèses, nous avons défini la route pour se connecter. Et c'est juste une autre façon d' écrire quelque chose comme ça. Nous pouvons également ajouter un autre
attribut ici, l'attribut de route, puis
simplement supprimer le login ici. Il s'agit essentiellement de la
même chose. Combinons donc simplement l'attribut HTTP post
avec l'attribut de route. Ensuite, nous avons
nos points de terminaison. Et maintenant, je dirais que nous sauvegardons
cela et que nous le testons déjà. Très bien, nous nous souvenons
que nous avons déjà nos utilisateurs, Iron Man et Batman. Nous pouvons donc
tester directement la méthode de connexion ici. Essayez-le donc. Par exemple, essayons
simplement de le tester. Testez-le avec une chaîne, chaîne que nous pouvons exécuter et nous voyons le
message correct introuvable. Et vous voyez également le code
d'état 400 ici. Jetons un coup d'œil ici dans l'onglet
Réseau, par exemple, réessayons. Appuyez sur Exécuter. Si vous le voyez à nouveau. Il s'agit du code d'état 400, qui signifie une mauvaise demande. C'est exactement
la même chose ici. Et maintenant, essayons avec
Iron Man, mais le mot de passe est une chaîne. Nous avons cliqué sur Execute, nous recevons
une mauvaise demande avec mot de passe erroné, c'est exact. Saisissez maintenant le mot de passe correct. Nous voyons notre
DTO de réponse d'Auth avec succès, vrai, sans message, sans jeton. Mais c'est ce que nous
allons changer ensuite. Nous allons enfin
créer le jeton Web JSON.
19. Créer et retourner un jeton Web JSON: Bon, alors revenons
à Visual Studio. Et maintenant, la première chose dont
nous avons besoin est en fait un secret. Parce qu'avec ce secret, le back-end peut vérifier si le jeton Web JSON auquel le serveur frontal ou l'
utilisateur envoie, le client envoie vers le
backend est réellement valide. Avec ce secret, nous
recréons le
jeton Web JSON et nous utiliserons également ce secret pour vérifier le jeton Web JSON et seul le backend
connaît ce secret. Le secret n'est pas disponible en substance
dans le jeton réel, alors seul le backend connaît le secret et la
largeur de ce secret. Nous pouvons vérifier le jeton Web JSON
réel. C'est très important et il existe plusieurs
façons de le faire. Bien sûr, vous pouvez modifier directement dans
le service d'authentification. Vous pouvez modifier dans un magasin, ou la manière la plus simple ici, dans notre cas dans cette classe, serait le fichier adjacent aux
paramètres de l'application. Nous ajoutons donc une autre section ici, nous appelons les paramètres de cette application. Et ensuite, nous entrons juste un jeton. Et ça peut être
tout ce que vous voulez. N'importe quel type de caractères
peut être utilisé ici, n'importe quelle séquence de caractères, comme ma clé top secrète, assurez-vous qu'il y
a au moins 16 caractères, caractères, n'est-ce pas ? La longueur minimale doit donc
être de 16 caractères. Et grâce à cela, nous pouvons désormais accéder à clé secrète de
jeton et
créer notre jeton Web JSON. Avec cela, nous allons maintenant
générer le jeton. Mais nous devons également insérer
quelques paquets NuGet. Mais cette fois-ci,
faisons cela en cours de route. Revenons à notre service hors service. Allons-y ici. Nous créons une nouvelle méthode, une chaîne
privée, Create Token, et nous
obtenons l'utilisateur ici. La première chose est que la liste des revendications et
nous avons besoin d'un autre espace de noms pour ces revendications de sécurité du système. Maintenant, c'est ce qu'on appelle les
revendications et il s'agit d'une
nouvelle liste de revendications. Ici. Maintenant, nous
définissons déjà quelques valeurs, alors ajoutons une nouvelle revendication. Avec identificateur de
nom des types de revendications. Il s'agit de l'ID de l'utilisateur. Par conséquent, l'ID utilisateur,
puis définissez cette chaîne sur une chaîne
ou les transfère dans une chaîne. Ajoutons-en un autre. Ainsi, la nouvelle revendication, le nom du type de réclamation, et ce sera alors
le nom d'utilisateur de l'utilisateur. Il s'agit déjà d'une chaîne, alors ajoutons simplement le composant ou nous
n'avons pas besoin d'une virgule ici. Non, pas encore, pas encore. Plus tard, lorsque nous ajoutons les routes, nous ajoutons une autre revendication ici. Je peux déjà vous dire
que quelles sont les revendications ? Eh bien, il s'
agit essentiellement d'informations provenant des données utilisateur qui seront stockées dans le jeton Web JSON
et nous allons jeter
un coup d'œil au jeton Web JSON, puis voir ce qui y est réellement
stocké. Donc, jusqu'à présent,
pour information, la revendication
représente une revendication. Vous pouvez donc stocker n'importe quoi, essentiellement toutes les
informations que vous voulez. C'est ce que nous voulons
stocker dans le jeton Web JSON. Avec cela, le client
qui sait, d'accord, quelle est l'idée de l'utilisateur
actuellement authentifié ou du nom d'utilisateur, etc. C'est vrai ? La prochaine étape est une clé, une clé de sécurité symétrique. Créons donc cette
chose avec la clé var, nouvelle clé de sécurité symétrique. Et nous avons déjà besoin d'
une autre référence ici. Cette fois-ci. Comme je l'ai déjà dit, nous avons
installé le package Microsoft Identity
Model deux jetons, trouvons et installons la dernière
version si vous ne la
voyez pas ici dans le menu
contextuel, s'il vous plaît. Rendez-vous à nouveau dans Gérer les packages
NuGet puis installez ce
package manuellement ici, ou faites-le comme ça. Il devrait donc être installé. Arrêtons ça. Et ça devrait être là. Nous avons le modèle
d'identité Microsoft est un espace de noms de
jetons. Déplacons
ce dernier très rapidement vers le programme CS parce que je
veux créer cette banque mondiale ici. Et maintenant, nous ajoutons
cet espace de noms. Super,
revenons donc à notre méthode. Nous avons notre clé de
sécurité symétrique, mais elle contient quelques arguments. La première chose est maintenant la première
et la seule chose à être plus exacte est notre secret. Avec notre clé top secrète, nous pouvons créer cette clé de sécurité
symétrique. Répondons donc à l'
encodage du texte du système, UTF-8, obtenez des octets. Et maintenant, nous devons
accéder à la configuration, qui est les paramètres de l'application JSON. Nous devons donc utiliser l'injection
de dépendances. Et nous le faisons ici. Donc, ce que nous avons besoin pour injecter cela, la configuration des yeux. Appelez cette configuration. Encore une fois, créez une attribution de
la configuration de champ, le soulignement ici, comme ça. Maintenant, ici, nous pouvons dire
la section configuration. Et ce sont maintenant, sont maintenant des
paramètres de cela, le jeton qui en découle. Maintenant, nous voulons la
valeur, fermez ça. Et nous avons notre clé de sécurité
symétrique. Avec cette clé, nous pouvons créer les informations d'identification de connexion également
nécessaires
à notre jeton. Appelons ce crédit. Maintenant, c'est assez complexe, mais c'est juste la façon de
créer un jeton Web JSON. J'espère que vous êtes toujours avec moi. Ce n'est pas le moment d'être
multitâche, par exemple. Alors, s'il vous plaît, revenez me si vous voulez écrire
le code avec moi. Nous connaissions maintenant la signature d'informations d'identification
avec notre nouvelle belle clé. Et nous avons besoin d'un algorithme. Et maintenant, utilisons les algorithmes
de sécurité. Je veux réellement
utiliser l'algorithme HMac SHA, Mac shot 12 signatures. Très bien, donc c'est ça. Avec ces crédits. Maintenant, avec ces informations d'identification
de connexion, nous pouvons créer un jeton
de sécurité JWT. Ainsi, jeton Web adjacent, jeton de sécurité, jeton var. Maintenant, un nouveau jeton de sécurité JWT. Nous avons besoin de quelque chose d'autre ici, jetons de
modèle d'identité
système JWT. Encore une fois, veuillez installer
ce package. Encore une fois, nous devons
ajouter quelques arguments ici. abord, la revendication est
donc stockée dans ce nouveau jeton. Ensuite, nous devons définir des dates
d'expiration. Et disons que cette chose
est valable pour un jour, donc datetime maintenant et les premiers jours. Très bien. La prochaine chose maintenant, les informations d'identification de signature
sont définies sur des crédits. Et retirons ce
truc ici et V est fini. Maintenant, c'est notre jeton et obtenez
également la chaîne finale, le jeton Web JSON final. Nous appelons var JWT, nouveau JWT,
jeton de sécurité, un gestionnaire. Ici, nous disons maintenant jeton avec le jeton, puis
nous retournons le JWT. Respirez profondément. Je sais que c'est complexe, mais c'est comme ça que ça se passe. qui est important, c'est que nous
conservons nos réclamations dans le JWT. Nous définissons des dates d'expiration ainsi que les
informations d'identification de connexion. C'est ici pour
notre clé top secrète et la section
jeton des paramètres de l'application. Encore une fois, c'est là. C'est notre clé secrète. Et maintenant, il est temps, bien
sûr, de rappeler cette chose
aux méthodes de connexion. Nous y sommes. Disons simplement un jeton de corde. Il s'agit maintenant de créer un jeton
avec notre utilisateur. Ici. Maintenant, nous avons mis le jeton, jeton, tout sécurise, ok, et je saurais,
disons, testons ça, vérifions
simplement parce que je pense que je l'ai
vu plus tôt, alors sauvegardons ça encore une fois. Et je pense que cela entraînerait
autrement une erreur. Nous allons donc ajouter la virgule ici. Et maintenant, testons
l'application. Essayons de vous connecter à nouveau. Essayez-le encore avec Iron Man. Si vous cliquez sur Execute, c'est le cas. Il s'agit de notre jeton Web adjacent
. Voici à quoi ressemble cette chose. Maintenant, il y a un beau côté appelé JWT. Oh, c'est là. Où coller
vos jetons Web JSON. Jetez un coup d'œil à
ce qu'il y a là-dedans. Et comme vous pouvez le voir ici, la première partie à la première
, la première période. Nous pouvons voir l'algorithme
et le type de jeton. Nous avons notre mélange h
de cinq douzièmes. Le type de jeton d'algorithme est un jeton JWT. Et maintenant, la charge utile
des réclamations, nous avons un identifiant de nom. Il s'agit de l'ID utilisateur et
aussi de la date d'expiration, ce qui va bien, le
lendemain et 21h14. Maintenant, nous pourrions
vérifier la signature. C'est donc très soigné,
la clé secrète, mais comme vous pouvez le constater, elle n'est pas disponible ici, seulement les nœuds back-end
de cette clé secrète. Et
regardons encore Batman. Batman et Frette. Nous cliquons sur Execute,
copiez-le , collez-le ici et vous voyez que
quelque chose a changé, c'
est-à-dire le nom identifiant, bien
sûr, c'est maintenant id2, comme vous pouvez le voir ici
également, ID 12. Et maintenant, nous avons une minute plus tard, c'est maintenant les dates
d'expiration. Très bien, donc ça marche. Nous avons notre
jeton Web JSON et que
devrions-nous en faire maintenant ? Eh bien, créons
un autre point
de terminaison disponible uniquement
pour autoriser les utilisateurs. Je dirais. Maintenant, avec ce point de terminaison, il est absolument
nécessaire d'ajouter ce jeton à l'en-tête
de votre demande. Et ce n'est qu'alors que vous pourrez, ou vous pouvez
accéder à ces points de terminaison. Et je dirais :
Allons-y ensuite.
20. Ajouter un point d'extrémité sécurisé pour les utilisateurs autorisés: Bon, revenons à Visual Studio. Créons ce point de terminaison maintenant. Et je le fais juste ici dans le contrôleur hors tension ni dans l'implémentation
du service. En fait, nous voulons simplement vérifier si l'utilisateur
est autorisé et
capable d'appeler cette chose. Maintenant, nous créons simplement
une méthode GetMethod avec HTTP. Encore une fois, il s'agit maintenant de notre méthode de requête
HTTP. Utilisons simplement les résultats d'une action
publique. Donc maintenant pas de tâche, pas de méthode asynchrone ici
et nous retournons simplement une chaîne. Et appelons cela Aloha
parce que j'adore la façon dont Y. Ensuite, nous pouvons aussi revenir. D'accord ? Aloha. Vous êtes autorisé. Ok, super. C'est donc notre point final, qui signifie que si nous appelons cela maintenant, tout le monde devrait pouvoir
accéder à ce message
ou recevoir ce message. Essayons ça très vite. Le voilà, la
GetMethod ici, l'API est désactivée. Nous avons essayé cela, nous avons
atteint les notes Execute, bien que ha, vous êtes autorisé. Tout le monde peut le faire. Mais maintenant, nous voulons
sécuriser cette chose. Et le moyen le plus simple
de le faire est
d'utiliser simplement les attributs autorisés. Autorisez-le donc,
Il n'est pas encore connu, donc nous devons utiliser l'espace de noms, autorisation
Microsoft ASP NET
Core. Et c'est tout. Super. Nous allons d'abord tester ça. Revenons donc à la vague. J'espère qu'il se reconstruira. Faites-le simplement manuellement
ici pour être absolument sûr. Ok. Maintenant, il a fait la
méthode GetMethod ici. Maintenant, nous avons essayé,
exécutez et nous obtenons une erreur. Je m'attends à ce qu'
aucun
schéma d'authentification n' ait été spécifié. Pour pouvoir
utiliser le jeton Web JSON, nous avons besoin d'un schéma
d'authentification. Alors, ajoutons
ça très vite. Nous revenons à nos programmes, oui. Et maintenant, ici, nous
devons encore écrire quelques trucs. D'abord les services Builder,
puis ajoutez l'authentification. Ce truc. Maintenant, en
restant un peu compliqué, nous voulons un porteur de
jeton Web JSON par défaut. Cela n'est pas connu, alors jetons un coup d'œil. Nous pouvons installer le
package Microsoft ASP.NET Core
Authentication, porteur JWT. C'est ce dont nous avons besoin, car il s'
agit d'un jeton porteur. Trouvez et installez donc
la dernière version. Lorsque cette chose est installée. Nous pouvons ensuite utiliser un schéma
d'authentification. Bien sûr, nous avons
arrêté l'application et maintenant elle sait ce qui
se passe ici. La valeur par défaut est utilisée
par l'authentification par paire. Porte-le terme « ours ». Peut-être que
vous l'avez déjà entendu. C'est juste un jeton porteur en
substance, c'est juste une ficelle. Il peut s'agir d'
une chaîne courte le long d'une chaîne, jeton Web
adjacent, autre
chose ? Il s'appelle juste porteur et vous verrez dans l'
en-tête, puis nous ajouterons également l'espace porteur de valeur ,
puis le jeton Web JSON. Mais nous verrons
cela dans une minute. Pour l'instant,
le schéma d'authentification ici. Maintenant, nous disons ajouter JWT Vera
avec quelques options. Bien sûr, ces
options ressemblent à cela. Nous avons donc d'abord des options, paramètres valides de
jeton,
qui sont de nouveaux paramètres de
validation de jetons et de nouveaux paramètres. Encore une fois, ils obtiennent des valeurs. Tout d'abord, nous validons la clé de signature du
problème. C'est vrai. Ensuite, la clé de
signature de l'émetteur elle-même, Quoi de plus,
est une clé top secrète. Encore une nouvelle clé
de sécurité symétrique. Encore une fois
des textes système encodant UTF-8. Ensuite, obtenez des octets. Ici. Créez maintenant une configuration. Obtenez les paramètres de section, le jeton
et, à partir de là, la valeur. Très bien, maintenant les
deux derniers valident le problème. Nous pouvons définir cela sur
false en fait et
valider également l'audience fausse. Et nous fermons ça
ici, et c'est tout. Formez ce petit espoir. Et maintenant, nous avons notre
intergiciel, essentiellement
le service logistique, ou simplement les services requis par les services d'
authentification. Alors maintenant, essayons encore
cette chose. Reconstruit. Jetons juste un coup d'œil. Nous
essayons cela pour qu'il s'exécute. Et maintenant, c'est génial, nous avons
une banque non autorisée. Donc pour 01 signifie autorisé. Encore une fois, nous pouvons vérifier deux fois. Quand on dit « Exécuter pour 01 », nous recevons ce sac. C'est la réponse, pas de
message, rien de tel. Ce n'est que le code d'état. Nous ne sommes pas authentifiés
et nous ne sommes pas autorisés à obtenir ou à accéder à
ce point de terminaison. C'est génial car nous n'avons pas envoyé d'en-tête avec cela. Encore une fois, nous pouvons jeter
un coup d'œil à l'onglet réseau
que vous allez exécuter. Et vous voyez que la réponse
est définie comme en-tête de requête, rien avec authentification
ou autorisation. C'est donc ce que nous
devons faire ensuite. Nous devons définir l'en-tête d'authentification en fonction de
nos demandes, de notre appel. Et pour cela, nous devons, bien changer ce vecteur
u est un peu. Encore une fois, nous devons faire des
choses dans les programmes, oui. Et nous devons également ajouter des
intergiciels pour que cela fonctionne. Ensuite, nous pourrons utiliser notre jeton Web JSON avec l'interface utilisateur
Swagger et les x,
le point de terminaison, le point de terminaison
autorisé. Alors, faisons-le ensuite.
21. Utilisez le JWT avec SwaggerUI & le Middleware d'authentification: Revenons au programme CS ici
à cette ligne X, vagueuse Jane, il faut
ajouter d'autres trucs. C'est plus gros. Jen a des options. En ce qui concerne ces options, nous disons que nous voulons ajouter une définition
de sécurité. Appelons ça OAuth2. Définissez ensuite un nouveau schéma de sécurité de
l'API ouverte. Laissez-moi enlever ça. Il suffit d'ajouter un autre espace de noms
ici. Et ici. Maintenant, nous pouvons donner à cette
chose une description comme en-tête d'autorisation
standard en utilisant le schéma porteur, par
exemple, le jeu. Ce sera alors, comme je l'ai dit, le porteur et ensuite
le jeton comme ça. Ce serait la description. Ensuite, nous pouvons définir
le paramètre dans. Alors, où voulons-nous
définir cela ou mettre ceci ? L'emplacement du paramètre
est l'en-tête. Ensuite, le nom est désactivé. Le type est le type de
schéma de sécurité, clé
API et l'ordre pour
pouvoir le définir, nous avons deux options. Filtre de fonctionnement, puis exigences de sécurité, filtre
des opérations. Et pour cela, nous devons
installer un autre paquet,
son filtre de fonctionnement. Ici, installez le paquet,
boucle oscillant. Nous arrêtons cela. Je pense qu'il s'installe maintenant. C'est là. Maintenant, c'était un peu rapide des filtres
ASP NET Core. C'est le paquet
dont nous avons besoin. Maintenant, nous n'avons pas fini. Nous devons également ajouter un autre
intergiciel ici. Ce sera AB, l'utilisation
de l'authentification. Il
le dit ici en tant que middleware
d'authentification de rappel Microsoft HP
au générateur d'
applications spécifié ce qui permet
des capacités d'authentification. C'est génial. Et maintenant, lançons
ça encore une fois. Nous revenons ici d'abord, vous le voyez déjà ici, nous
avons un nouveau bouton d'autorisation. C'est ici que nous pouvons maintenant
ajouter notre jeton. Nous allons d'abord nous connecter ici avec Iron Man, puis
poivrons et exécutons. Nous copions le jeton. Maintenant, nous pouvons définir cela ici, porteur puis l'espace porteur de
jetons, puis le jeton que nous
pouvons autoriser. Maintenant, nous essayons de lancer
ça, frappe exécute. Et voilà, nous récupérons
notre message. Et ici, nous pouvons voir que c'est l'
en-tête d'autorisation que nous avons dit. Nous allons simplement vérifier
ici dans l'onglet Réseau. Appuyez à nouveau sur Exécuter. Nous avons vu dans nos
en-têtes de demande, nous avons dit autorisation, en-tête d'autorisation,
porteur, puis jeton. Maintenant, tout fonctionne. Nous avons créé le jeton Web JSON, pu l'utiliser et obtenir un accès autorisé à
un point de terminaison autorisé. Super. Il s'agit essentiellement
du premier grand chapitre, et le prochain chapitre
est maintenant le jeton de rafraîchissement.
22. Refresh Jetons Introduction: Maintenant, cela a déjà fonctionné. C'est parfait. Mais la question est maintenant lorsque vous avez votre jeton Web
JSON, il arrive bientôt à expiration, ou il se peut
qu'il y ait un attaquant. Et avec cet attaquant, votre jeton Web JSON
n'est plus sécurisé. Ainsi, cet attaquant saisit votre jeton Web
JSON et
utilise ensuite cette chose pour s'authentifier et
vous ne voulez pas le faire. C'est pourquoi nous utilisons dates d'expiration
plus courtes pour nos jetons Web JSON, comme
15 minutes, par exemple. Lorsque nous faisons cela, pour obtenir un nouveau jeton Web JSON, nous avons besoin d'un jeton d'actualisation
car sinon, si j'ai un
tokenisme adjacent valide. Et vous, en tant qu'utilisateur, souhaitez
toujours utiliser
une application Web avec le jeton Web JSON, cela ne fonctionnerait pas, mais ce que vous pouvez faire alors, et c'est une essence, la responsabilité
du front end. Ce que vous pouvez faire, c'est
que vous
pouvez utiliser un jeton d'actualisation valide beaucoup plus longtemps, par
exemple une
semaine, sept jours. Il est donc plus difficile d'obtenir
ce jeton de rafraîchissement, donc ce n'est plus si facile
pour un attaquant. De plus, lorsque vous utilisez
ce jeton d'actualisation, nous actualiserons non seulement
le jeton Web JSON, mais également le
jeton d'actualisation lui-même. Alors, tout est nouveau. Et vous, en tant qu'utilisateur, ne remarquez rien là-dessus. Mais vous êtes toujours authentifié. Autoriser aussi peut-être que
tout est sécurisé, n'est-ce pas ? Jetons donc un coup d'œil aux jetons de
rafraîchissement.
23. Ajouter les données de jeton de rafraîchissement au modèle utilisateur: Très bien, la
première étape de notre jeton d'actualisation est que nous
voulons stocker le jeton d'actualisation avec la
date et l'heure ce jeton a été créé
et quand il expire. Vous souhaitez stocker cela dans la base de données
avec l'utilisateur. La première étape consiste donc à étendre ce modèle utilisateur ici, nous ajoutons une autre chaîne, qui est le jeton d'
actualisation réel. Obtenir cela peut être une chaîne
vide comme ça. Et puis, à une date et une
heure, une propriété. premier est un jeton
créé et le suivant, le
jour, puis le jeton expire et vous souhaitez le stocker ou ajouter une autre migration
à la base de données. Alors, faisons-le. Si votre application est en cours d'exécution, veillez à l'arrêter. Il suffit de fermer le terminal ,
puis de passer à la console
Package Manager. Où sommes-nous ? Eh bien, nous devons
changer le répertoire. Ok, et maintenant nous entrons dans migrations
Dotnet EF lors de l'actualisation des données de
jeton par exemple. Jetons un coup d'œil
au fichier de migration. C'est là. Nous voyons que de
nouvelles colonnes seront ajoutées pour être utilisées comme tableau. Et si nous annulons
la migration, seront-ils supprimés ? Donc, c'est bon. Nous mettons à jour la
base de données avec dotnet. Mises à jour des bases Très bien, ouvrons à nouveau
la base de données. L'ouverture, et maintenant nous le voyons
déjà ici. Nous avons le
jeton de rafraîchissement et les dates. Et ici aussi la
structure de la table. Super, donc c'est fait. Nous avons nos données de jeton d'actualisation ainsi que les données utilisateur. Et l'étape suivante
consiste à créer le jeton d'
actualisation lors de la connexion.
24. Créer le jeton Refresh sur Login: Maintenant, pour créer un
retour également le jeton d'actualisation, la première chose
dont nous avons besoin ici est, eh bien, nous pouvons étendre la réponse de l'
auteur DTO et les
données ici également. Vous pouvez maintenant
voir pourquoi il est
logique de créer cette réponse d'
authentification DTO, nous ne pouvons pas seulement envoyer
l'indicateur de succès avec un message et
le jeton Web JSON, nous pouvons également envoyer le jeton d'actualisation et quelques données avec ce jeton d'
actualisation. Parce que c'est alors la
responsabilité du front end de
décider quand actualiser
ce jeton de rafraîchissement. Mais nous le verrons
dans les prochaines leçons. suffit donc d'
ajouter d'abord les propriétés. La première chose à faire est donc
le jeton de rafraîchissement réel. Par défaut encore,
il s'agit d'une chaîne vide. Et maintenant aussi,
ajoutons la date d'expiration, donc le jeton va expirer. Et maintenant, une autre chose qui a
du sens et qui nous facilite la vie est
d'ajouter un modèle de jeton de rafraîchissement. Nous ne stockerons pas
cela dans la base de données, nous ne le retournerons pas. Mais dans notre logique, nous utiliserons ce modèle de jeton d'
actualisation pour placer les données ici. Ensuite, vous utilisez ces données
pour effectuer d'autres tâches telles que la
définition du
jeton d'actualisation dans le cookie. Créons donc
un autre modèle ici, une autre classe et appelons
cela maintenant un jeton de rafraîchissement. Ici, nous disons corde d'accessoires. Le jeton de rafraîchissement est
une chaîne vide. Ensuite, nous disons la date, l'
heure, la crée, et
appelons ce jeton uniquement. Désormais, la date et l'heure expire. Bon, revenons maintenant
au service d'authentification. Et ici, nous pouvons maintenant créer notre méthode pour créer
le jeton de rafraîchissement. Encore une fois, c'est une autre méthode
privée, le jeton de rafraîchissement de création privée. Et il renvoie également
un jeton de rafraîchissement. Voyez maintenant qu'il est déjà logique d'utiliser le modèle de
jeton d'actualisation ici. Et cette chose maintenant, bien
sûr, un nouveau jeton de rafraîchissement. Et ici, nous disons simplement que le jeton
convertit en chaîne de base 64, puis en
octets de générateur de nombres aléatoires, puis 64. C'est ainsi que nous créons
notre jeton de rafraîchissement. Vous voyez qu'il s'agit simplement d'une chaîne
de plusieurs caractères, donc rien de fantaisiste comme
le jeton Web JSON. Il s'agit de notre jeton de rafraîchissement, et ici, il sera valide
pendant une semaine et il est créé. Maintenant, à la fin, nous retournons ce jeton de rafraîchissement. D'accord ? Maintenant, lorsque nous l'avons obtenu, nous pouvons utiliser cette
méthode lors de la connexion. Donc, ici, dans méthode de
connexion après avoir créé
le jeton Web JSON, nous pouvons maintenant dire que notre jeton d'actualisation est de créer un jeton d'actualisation. Placez cette chose ici, bien sûr. On peut donc peut-être formater
ce peu différemment. Nous disons que le jeton d'actualisation, le jeton d'actualisation
et le jeton expire, date est le jeton d'actualisation expiré. Maintenant, nous sauvegardons cela et
le testons très rapidement avec swagger. Nous y sommes. Nous allons vous connecter. Essayez ça, mec, pappa et exécute. Et c'est là. Nous avons notre jeton Web JSON
et maintenant le jeton d'actualisation. C'est ainsi que cette chose ressemble à la date
d'exploration. Parfait. Et maintenant,
l'étape suivante consiste à stocker ce jeton dans la base de données
avec l'utilisateur et à l'ajouter à un cookie. Alors, faisons-le ensuite.
25. Définir Refresh Token dans Cookie & dans la base de données: Maintenant, pour définir le
jeton d'actualisation sur un cookie, nous avons besoin de
la requête et de l'objet réponse hors de l'API Web. Et pour pouvoir
accéder à cette chose, nous avons besoin de l'exercice de
contexte http. Nous voulions donc accéder
aux contextes HTTP, l'utiliser dans le contrôleur. Juste ici. Il serait
déjà disponible ici. Vous disposez déjà
du contexte HTTP. Et grâce à cela, vous pouvez
simplement accéder à la réponse. Par exemple, lancez
ici les en-têtes de réponse, puis
les en-têtes de requête, etc. Vous pouvez donc déjà le faire ici. Mais comme nous voulons
utiliser le service ici, nous devons d'abord injecter l'exercice contextes
HTTP. Faisons ça très vite. Ici, dans le
constructeur, nous disons que je suis un exercice de contexte HTTP. Appelons également cela l'exercice de contexte
http. Et encore une fois, nous créons ces champs et un
soulignement ici et ici. Et nous devons également enregistrer cette chose et nous le
faisons, peut-être arrêtons d'abord
l'application. Ok, et maintenant dans le
programme CS, ici, nous pouvons simplement dire les services de
création,
puis ajouter un exercice de contexte HTTP. C'est ça. Ok, donc avec cela, nous avons notre accesseur de
contexte HTTP et nous avons enregistré ce truc. Et maintenant, nous pouvons créer
notre méthode pour définir ce jeton dans le cookie et
dans la base de données. Ici encore,
une autre
méthode privée , Async cette fois, mais nous ne retournons rien de jeton de
rafraîchissement. Et cette chose récupère
les objets de
jeton d'actualisation et
ensuite l'utilisateur. C'est donc ce dont nous avons besoin. Et maintenant, nous
commençons par le cookie. Et un cookie nécessite des options de
cookies. Tout d'abord, les
options de cookies, les nouvelles options de cookies. Et ici, nous disons qu'
il s'agit d'un cookie uniquement HTTP. Cela signifie qu'il est uniquement
accessible via la demande, via les appels et non via
JavaScript dans le navigateur. C'est important. Et c'est le seul endroit
où nous avons besoin de ce cookie. Et nous pouvons également définir
l'étape de l'exploration pour que le jeton d'actualisation expire. C'est déjà
les options de cookies et maintenant avec l'exercice de
contextes HTTP, puis il peut être nul. Ici, nous pouvons accéder
aux contextes HEB. À partir de là, nous avons
défini la réponse. Et ici, nous pouvons
accéder aux cookies. Et ici, nous
venons de dire que ça dépend. La valeur est appelée jeton d'
actualisation. Ensuite, le jeton de rafraîchissement. Token, c'est la valeur. Et nous donnons également cette chose, les options de cookies,
et c'est ainsi que nous définissons le cookie
dans notre réponse. La prochaine chose maintenant,
c'est aussi l'utilisateur. Le jeton d'actualisation de l'utilisateur
sera donc configuré pour
actualiser le jeton de jeton. Ensuite, nous avons créé un
jeton utilisateur, qui est un jeton d'actualisation créé. La dernière chose que le
jeton utilisateur expire, c'est que le
jeton d'actualisation expire et en fin de compte, on dit « Attendre
les contextes »,
puis « Enregistrer les modifications asynchrones ». D'accord ? Et encore une fois,
nous l'utilisons maintenant dans notre méthode de connexion. Là-haut. Après avoir créé
le jeton d'actualisation, nous disons définir le jeton actualisation
avec nos
objets jeton d'actualisation et l'utilisateur. Sauvons ça et
encore une fois, testez cette chose. Très bien, nous y
sommes. Et maintenant, ouvrons
déjà la console ici. Parce que je veux vous
montrer quelque chose dans l'onglet Application, vous voyez notre application actuelle
localisée sept O huit. Nous voyons ici que nous pouvons accéder aux cookies réels,
mais jetons un coup d'œil. l'onglet Réseau,
nous avons essayé de vous connecter. Encore une fois, disons qu'avec Iron
Man Pepper, on touche Execute. Et vous voyez ce que nous récupérons. Et maintenant ici, nous
voyons d'abord dans les en-têtes, dans la réponse, nous voyons cette
chose ici, mettre des cookies. s'agit donc de notre cookie actuel, il est maintenant défini comme un cookie
HTTP uniquement. Le jeton d'actualisation est défini
comme un cookie HTTP uniquement. Et maintenant, nous pouvons également le trouver dans l'onglet de l'application
ici. C'est là. Faisons en sorte que cela soit un peu plus grand. Peut-être que nous avons
le jeton de rafraîchissement de valeur et le
jeton de
rafraîchissement du nom. Et maintenant, ici aussi la valeur. Et ce qui est génial, c'est
maintenant que
cette chose est automatiquement envoyée à chaque demande. Donc, si, par exemple, vous voulez obtenir ceci ici, par
exemple, essayez-le, il s'exécute, accédez à l'onglet Réseau. Bien sûr, nous ne sommes pas autorisés, mais nous voyons que dans
notre en-tête de demande, envoyez ce jeton d'actualisation. C'est important maintenant
pour les prochaines étapes car nous sommes en mesure de
définir le jeton d'actualisation. Lorsque nous créons un jeton d'actualisation, nous définissons un
jeton d'actualisation dans le cookie et également ici dans la base de données. Nous pouvons maintenant voir ce jeton de rafraîchissement
complet. Maintenant, l'étape suivante est bien d'
actualiser le jeton d'actualisation et le
jeton Web JSON, bien sûr, car l'important ici avec le jeton d'actualisation
est que dès qu' un site Web JSON jeton expire ou quelques secondes ou quelques
minutes avant. Il incombe au frontal
d'appeler d' autres points de terminaison qui
permettent ensuite à l'utilisateur d'
actualiser le JWT, le jeton Web JSON et
le jeton d'actualisation. Et même lorsque le jeton
Web JSON a expiré, il n'est plus valide à l'
aide du jeton d'actualisation
valide plus longtemps, nous sommes en mesure de créer un nouveau jeton
JWT et une nouvelle
actualisation jeton afin que l'utilisateur soit toujours authentifié et autorisé
et que l'utilisateur n'ait
pas besoin de s'authentifier à nouveau avec le
nom d'utilisateur et le mot de passe. C'est donc ce qui est génial
du jeton de rafraîchissement. Mais pour cela, nous avons besoin d'
un autre point de terminaison où nous pouvons actualiser le package
complet. Alors, faisons-le ensuite.
26. Refresh the Refresh Token (et le JSON Web Token): Revenons à Visual Studio. Et dans l'interface, nous
créons ces nouvelles méthodes, tâche hors réponse DTO. Nous appelons ce méthanol
également un jeton de rafraîchissement. Et il n'a aucun
argument. Oui, nous reconstruisons, mais nous
obtiendrons une flèche bien sûr, car cela n'est pas mis en œuvre. Mais allons le faire
maintenant très rapidement. Implémentez l'interface, alors que nos méthodes sont probablement ici. Oui, mettons ça en place. Nous avons l'utilisateur du registre. Allons ici maintenant. Il existe notre méthode de rafraîchissement des
jetons. Encore une fois, si vous sautez la
fin de la dernière leçon, il est important
que le
front-end appelle cette chose. Dès que le jeton
Web JSON a expiré ou peu
avant ou après. Ensuite, le front-end doit
appeler ce point de terminaison ici. Eh bien, ce n'est pas le point final, c'est la méthode de service, mais bien sûr, le
point de terminaison sera créé dans le
contrôleur dans une minute. Mais maintenant, avec cette méthode, nous pouvons tout rafraîchir. La première chose dont nous avons besoin, c'est ce jeton de rafraîchissement
actuel. Je vous ai donc déjà dit qu'
à chaque demande maintenant, le jeton d'actualisation
sera envoyé avec notre exercice de contexte, l'exercice de contexte
HTTP. Ensuite, les contextes HTTP. nous pouvons accéder à la demande Cette fois-ci, nous pouvons accéder à la demande et non à la
réponse aux demandes, et rechercher une
certaine valeur de cookie, ce qui serait
le jeton d'actualisation. Après cela, avec le jeton d'
actualisation, réessayez obtenir l'utilisateur avec
le jeton d'actualisation. Ainsi, l'utilisateur var Waitz contexte les utilisateurs en premier
ou asynchrone par défaut, où le jeton d'actualisation de l'utilisateur
est maintenant le jeton d'actualisation, celui donné par le cookie. Maintenant, si vous ne trouvez pas l'utilisateur, nous disons renvoyer une nouvelle réponse d'
authentification avec le message de meth, jeton d'actualisation
non valide. Une autre option, bien sûr, est si vous trouvez un utilisateur, mais que le jeton utilisateur a expiré. Par conséquent, parler expire est
plus petit qu'une date et une heure. Maintenant, dans ce cas, nous retournons à nouveau le nouveau DTO de
réponse d'authentification avec message. Et cette fois,
le message peut simplement expirer. Dans ce cas, l'
utilisateur devra
s'authentifier à nouveau avec
le nom d'utilisateur et le mot de passe. Mais si tout est valide, nous avons un
jeton utilisateur toujours valide. Encore une fois, nous créons un nouveau jeton. C'est le
jeton Web JSON avec notre utilisateur. Ensuite, nous créons un
nouveau jeton de rafraîchissement. Créez un jeton de rafraîchissement. Et définissez aussi ce truc. Définissez le jeton d'
actualisation, le nouveau jeton d'actualisation et l'utilisateur. En fin de compte, nous retournons
une nouvelle réponse de l'auteur, DTO. Le succès est vrai. Le jeton est le
jeton, rafraîchissement. Nouveau jeton de rafraîchissement, jeton. Et nous avons défini le jeton qui expire pour que le nouveau jeton d'actualisation expire, c'était déjà le cas et
cela devrait être tout. Encore une fois très vite, cette ligne
ici est vraiment importante. Nous récupérons le jeton d'actualisation de la valeur du
cookie HTTP uniquement. Et à partir de là, nous avons essayé de
trouver l'utilisateur cette fois, non pas avec l'ID utilisateur, mais avec le jeton d'actualisation, car il s'agit d'un jeton
uniquement pour un utilisateur spécifique. Et si vous n'avez pas l'utilisateur, le jeton d'actualisation n'est pas valide. Si le jeton a
expiré,
nous retournons un autre message indiquant que nous retournons un autre message indiquant le jeton a expiré et l'indicateur de
succès est faux. Sinon encore, nous avons configuré
le jeton Web JSON pour créer le jeton Web JSON
similaire au verrouillage, nous créons un nouveau jeton d'actualisation
et définissons cette chose, puis retournons le package complet. Très bien, maintenant nous avons
besoin des points de terminaison. Donc, pour notre contrôleur, nous allons peut-être éditer ici. Encore une fois, un
message HTTP avec bien qu'un
GET fonctionne également, mais utilisons un post
ici et rafraîchissons le jeton. Et la méthode maintenant je suis paresseuse, alors copions le résultat de cette action de
tâche,
puis une chaîne. Nous appelons cela ici maintenant, rafraîchir le jeton, pas d'arguments. Et nous appelons le jeton d'actualisation
sans argument car encore une fois, le jeton d'actualisation est livré
avec le cookie de demande. S'il réussit, nous
retournons une réponse OK. Si ce n'est pas le cas, nous renvoyons
une mauvaise demande. Je dirais qu'il est temps de
tester à nouveau ça.
Lançons l'application. Très bien, nous y voilà. J'ai supprimé le cookie ici
de l'onglet Application. Comme vous pouvez le constater, un
cookie est vide. Nous n'avons aucun jeu de jetons d'actualisation, et l'
onglet Réseau est également vide. Nous allons donc tester encore une fois. Nous allons nous connecter, essayer ça avec Iron Man Pepper
par exemple, et nous exécutons. Tout va bien. Nous recevons notre
jeton Web JSON, le jeton de rafraîchissement. Nous le voyons également ici dans
l'onglet de l'application. Et maintenant, lorsque j'essaie d'exécuter le
point de terminaison de jeton d'actualisation ici ou que j'appelle cette impression et l'exécute. Cela fonctionne, nous recevons un
nouveau jeton de rafraîchissement. Vous le voyez ici dans
les changements de valeur. Que se passe-t-il maintenant ? Au fait, bien sûr,
dans la base de données ? Nous pouvons également y jeter un coup d'œil. Rafraîchissons ça. Ici, nous voyons
exactement le même jeton. Et maintenant, lorsque je retire le neuf ici et que je clique sur Exécuter, encore une fois, nous recevons le message
d'erreur correct, jeton d'actualisation
non valide, le remettons et maintenant cela fonctionne. Et qu'en est-il de la date ? Nous avons ce nouveau
jeton ici et nous voyons que date d'expiration est fixée au 16 mai. Laissez-moi juste changer
la date sur ma machine. Modifiez-le, définissez cela maintenant pour
indiquer 20e, peut-être changer. J'ai encore essayé de rafraîchir
le jeton. Il est dit que le jeton a expiré. Ok, super, donc ce
point de terminaison fonctionne totalement. Et encore une fois, c'est la
responsabilité du front end. Je ne peux pas le
dire suffisamment pour que le frontal ou
le client doive vérifier. Y a-t-il un jeton Web adjacent qui expire ou a déjà expiré ? Dans ce cas, nous devons récupérer
un jeton d'actualisation et appeler le point de terminaison du jeton d'actualisation
pour obtenir un nouveau jeton d'actualisation. Très bien, et avec
cela, nous en avons fini avec les jetons de rafraîchissement et
le dernier chapitre maintenant, les routes et le grand
sujet, l'autorisation.
27. Introduction aux rôles: Il s'agit maintenant des points de terminaison
pour l'enregistrement, pour la connexion, pour
le jeton d'actualisation. Et maintenant, la dernière partie
devrait être le rôle. Nous avons notre
objet utilisateur dans la base de données, mais il n'a pas encore de rôle. Mais maintenant, cela va changer. Ce que nous allons
faire ensuite, c'est que nous
ajouterons le rôle lors d'une nouvelle migration. Ce champ est donc dans la base de données le
rôle de l'utilisateur. Nous utiliserons également les revendications pour ajouter ce rôle dans
le jeton Web JSON. Ensuite, lorsque l'
utilisateur essaie d'appeler un point de terminaison donné
et que l'utilisateur doit être autorisé
pour ce point de terminaison. Ensuite, nous pouvons vérifier cela dans l'API Web
avec un autre attribut. Par exemple, vous avez peut-être le rôle d'utilisateur
ou de client typique, mais aussi un rôle d'
administrateur dans seuls les administrateurs peuvent appeler certains points de terminaison. C'est donc ce que nous
allons vérifier ensuite.
28. Ajouter un rôle au modèle d'utilisateur: La première chose,
encore une fois pour nos rôles c'est d'
ajouter le rouleau au modèle utilisateur et d'ajouter une nouvelle migration. Ici, dans le modèle utilisateur, nous ajoutons une nouvelle propriété. Il s'agirait alors d'une
chaîne simplement avec la ligne et une chaîne vide. Par défaut, nous sauvegardons cela et maintenant nous effectuons
une autre migration. migrations Dotnet EF
utilisent donc la ligne par exemple. Très bien, maintenant nous voyons cette chose ici dans notre dossier
migrations. Nous venons d'ajouter une nouvelle colonne. C'est très bien. Nous allons donc
mettre à jour la base de données avec la base de données dotnet EF. Jetons maintenant un coup d'œil. Voici nos utilisateurs. Nous actualisons les données, nous voyons la nouvelle ligne ici, et bien sûr, nous pouvons la modifier. Par exemple, nous pouvons
maintenant dire que l'Iran a
l' utilisateur de ligne que nous avons cliqué sur Appliquer. Et si vous modifiez
quelque chose ici, assurez-vous dans le navigateur DB pour SQL Light que vous cliquez sur
ce bouton ici, n'est-ce pas ? Changements. Maintenant, ces modifications sont
écrites et enregistrées. Bon, il s'agit maintenant du nouveau
rôle et du modèle utilisateur. Ensuite, nous ajoutons la
revendication de la règle S au jeton Web JSON.
29. Ajouter un rôle comme revendication au jeton Web JSON: Nous revenons donc
au service d'authentification puis lorsque nous
créons le jeton ici, nous pouvons simplement ajouter la
ligne maintenant en tant que nouvelle revendication. Nous ajoutons donc simplement une nouvelle revendication, puis des types de
revendications, puis une ligne. Ici, cela suggère
déjà la bonne chose, la ligne
d'utilisateur, c'est la bonne
chose. C'est déjà ça. Nous pouvons donc déjà tester
si le rôle actuel de l'utilisateur est disponible
dans le jeton Web JSON. Jetons un coup d'œil. Il y a notre application. Reconnectons-nous. En passant, si vous
êtes toujours verrouillé ou si vous avez le jeton d'actualisation disponible dans
votre cookie, vous pouvez utiliser simplement le point de terminaison du
jeton d'actualisation ici pour obtenir le nouveau jeton Web
JSON. C'est ce qui est génial
maintenant avec les jetons de rafraîchissement, vous n'avez pas à vous
connecter à nouveau comme je le dois parce que j'ai
tout supprimé de mes cookies. Dans ce cas, vous pouvez simplement utiliser le point de terminaison du jeton
Refresh et obtenir un nouveau
jeton Web JSON. Vous venez de regarder dedans. Et maintenant, nous voyons ici
le jeton Web JSON. Prenons ce truc. Jetez un coup d'œil ici,
nous le collons à nouveau. Et nous devrions voir, oui, c'est là, le rôle maintenant, qui est l'utilisateur. Super, donc ça fonctionne déjà. La dernière étape
consiste à utiliser cette ligne pour l'
autorisation afin que seuls des utilisateurs spécifiques ayant un rôle spécifique puissent
accéder à certains points de terminaison. Alors, faisons-le ensuite.
30. Utiliser le rôle de l'autorisation: Maintenant, nous allons simplement utiliser la situation
actuelle. Nous essayons d'obtenir un nouveau jeton Web
JSON ici. Cela fonctionne maintenant parce que nous avons
déjà reçu un jeton de rafraîchissement. Encore une fois, nous vérifions cette chose ici et vous voyez l'utilisateur du rôle. Maintenant, allez dans notre getc appelé
ici et cliquez sur, Essayez-le. Vous le voyez pour un ou vous
n'êtes pas authentifié ou autorisé. Nous ajoutons maintenant le jeton
Web JSON ici. Cliquez sur Execute, nous allons obtenir
Aloha, vous êtes autorisé. Mais que se passe-t-il si nous ne
voulons que les administrateurs, par
exemple, utiliser ce point de terminaison. Ainsi, le rôle d'administrateur, par exemple, nous pouvons changer cela très rapidement. La manette Off. Ici, nous voyons où il est là, ce
n'est pas ici. En bas, ici. Nous pouvons simplement ajouter
entre parenthèses rho. Ensuite, admin
par exemple, nous sauvegardons cela. Il suffit de redémarrer l'application. Nous sommes donc à nouveau verrouillés, mais à l'aide de
notre jeton d'actualisation, nous obtenons un nouveau jeton Web JSON afin ne pas avoir à
nous
connecter manuellement. Autorisons encore une fois. Appuyez sur Autoriser, fermez. Maintenant, nous avons essayé d'obtenir ce
truc ici et nous avons obtenu un 403. Maintenant 403 Interdit. Cela signifie donc que nous envoyons un en-tête
d'autorisation. Nous avons envoyé un jeton
Web JSON clé ici, mais avec la mauvaise ligne. Maintenant, changeons notre rôle ici
au lieu d'utilisateur, nous disons maintenant administrateur, il s'applique et écrit les modifications. Et maintenant encore,
rafraîchissons le jeton. Très bien, donc nous allons encore copier
cette chose en entendant. Nous devons utiliser ce jeton ici. Maintenant, nous cliquons sur Autoriser et maintenant 1 septième aloha,
vous êtes autorisé. Super. Désormais, en tant qu'administrateur
avec ce rôle spécifique, nous sommes autorisés à obtenir ces informations ici ou
à accéder au contenu, aux informations
de ce point de terminaison. Maintenant, la dernière chose que de
nombreux utilisateurs, beaucoup d'étudiants se demandent, c'est qu' en
est-il de plusieurs rôles
lorsque vous voulez autoriser
plus de barres qu'un seul. Eh bien, saisissez simplement
l'utilisateur, puis Admin. Et cela fonctionne également. Redémarrons l'application
manuellement pour être sûr. Maintenant, lorsque nous utilisons le
même jeton ici, nous cliquons sur Autoriser, fonctionne toujours. Et le dernier test, disons encore une fois, nous voulons donner à cet
utilisateur la ligne d'utilisateur. Nous écrivons le changement. Encore une fois, nous recevons un nouveau jeton. Il s'agit maintenant du
jeton utilisateur que vous voyez ici. Il s'agit maintenant d'un utilisateur. Et nous cliquons sur Autoriser une déconnexion, Berra, fermez, exécutez, et nous obtenons toujours le
contraire, vous êtes autorisé. C'est maintenant comme ça que fonctionnent les routes. Et avec cela, nous en avons
fini avec ce cours. Félicitations.
31. Derniers mots: Très bien, et
c'est déjà en peu de temps que vous avez
appris à enregistrer des utilisateurs, à les
verrouiller et à créer des jetons Web
JSON. Utilisez également des jetons d'actualisation et vous avez ajouté
des rôles à cet utilisateur. Maintenant, je pense que vous
connaissez déjà tous les fondamentaux d'un
processus d'authentification avec dotnet six, j'espérais vraiment que vous
appreniez quelque chose et cela vous a été utile. Si c'est le cas, j'aimerais voir un avis. Merci beaucoup pour cela. Et peut-être
voulez-vous vous plonger plus en profondeur dans dotnet et blazer et d'autres membres du personnel concernant le développement
Web. Et dans ce cas, j'
aimerais
vous voir sur ma chaîne YouTube. Encore une fois, je
vous remercie beaucoup votre temps et je vous
remercie d'avoir rejoint mon cours. Et j'espère vous voir dans le prochain cours ou sur
ma chaîne YouTube. Prends soin de toi.