[Node.js] Authentification d'identité, mécanisme d'authentification de cookie et de session, utilisation de l'authentification de session et de l'authentification JWT en mode express

Modèle de développement Web

• Modèle de développement Web traditionnel basé sur le rendu de serveur

• Le concept de rendu côté serveur est que la page HTML envoyée par le serveur au client est générée dynamiquement par le serveur via l'épissage de chaînes. Par conséquent, le client n'a pas besoin de technologies telles qu'Ajax pour demander des données de page supplémentaires.

avantage:

• Le front-end prend moins de temps, ce qui est bon pour le référencement (c'est-à-dire qu'il est plus facile pour les crawlers d'explorer et d'obtenir des informations, ce qui est plus propice au référencement)

défaut:

• Occupant les ressources du serveur, trop de requêtes mettront la pression sur le serveur
• Il n'est pas propice à la séparation des frontaux et des back-ends, et l'efficacité du développement est faible

//服务器通过字符串的拼接,发送给前端
app.get("/user", function (req, res) {
    
    
	const user ={
    
    name:'乞力马扎罗',age:'24'}
    // res.send()方法，可以把处理好的json内容，发送给客户端
    res.send(`<h1>姓名:${
      
      user.name},年龄：${
      
      user.age}`)
})

• Un nouveau modèle de développement web basé sur le rendu de séparation front-end et back-end

• Modèle de développement à deux points avec séparation avant et arrière, reposant sur la large application de la technologie Ajax
• Autrement dit, le backend est uniquement responsable de fournir l'interface API, et le frontend appelle le mode de développement de l'interface Ajax

avantage:

• L'expérience de développement est bonne, le front-end se concentre sur les pages d'interface utilisateur et le back-end se concentre sur le développement d'API
• Bonne expérience utilisateur, Ajax peut facilement réaliser un rafraîchissement partiel de la page
• Réduction de la pression de rendu côté serveur

défaut:

• Ce n'est pas propice au référencement, car la page HTML complète doit être dynamiquement cousue côté client, de sorte que le crawler ne peut pas extraire les informations effectives de la page (la solution, en utilisant la technologie SSR frontale telle que vue, React, etc. ., peut très bien résoudre ce problème)

Comment choisir un modèle de développement web

• Par exemple, un site Web au niveau de l'entreprise dont la fonction principale est de s'afficher sans interaction complexe et nécessite un bon référencement, alors le rendu côté serveur est requis
• Semblable aux projets de gestion d'arrière-plan, il est hautement interactif et n'a pas besoin de prendre en compte le référencement, vous pouvez donc utiliser le mode de développement de séparation front-end et back-end
• Bien sûr, parfois afin de tenir compte de la vitesse de rendu de la page d'accueil et de l'efficacité de développement de la séparation front-end et back-end, certains sites adoptent le mode de développement du rendu serveur premier écran + front-end et back-end séparation des autres pages

Authentification

Qu'est-ce que l'authentification d'identité

• L'authentification de l'identité, également appelée vérification et authentification de l'identité, fait référence à la confirmation de l'identité de l'utilisateur par certains moyens.
• Dans le développement Web, l'authentification de l'identité de l'utilisateur est impliquée. Par exemple, connexion par code de vérification de téléphone portable, connexion par mot de passe par e-mail, connexion par code QR des principaux sites Web

Pourquoi l'authentification

• Le but de l'authentification d'identité est de confirmer que l'utilisateur qui prétend actuellement être une certaine identité est bien l'utilisateur revendiqué,
• De même, lorsque vous récupérez le coursier, sortez votre code de retrait ou votre numéro de téléphone portable

Authentification pour différents modes de développement

Deux modes de développement basés sur le rendu du serveur et la séparation front-end et back-end, chacun avec des schémas d'authentification différents

• Il est recommandé d'utiliser le mécanisme d'authentification de session pour le rendu côté serveur
• Il est recommandé d'utiliser le mécanisme d'authentification JWT pour la séparation front-end et back-end

Mécanisme d'authentification de session

Comprendre l'apatridie du protocole HTTP

Cela signifie que chaque requête http du client est indépendante, qu'il n'y a pas de relation directe entre plusieurs requêtes consécutives et que le serveur ne conservera pas activement le statut de chaque requête HTTP.

Semblable aux caissiers de supermarché qui ne se souviennent pas si chaque client qui passe à la caisse est un VIP

Comment briser la limitation sans état de HTTP

Lorsque le client se connecte avec succès, le serveur émet une connexion réussie au client, de sorte que lorsque le client se connecte pour la deuxième fois, il peut porter ce logo (Cookie) pour indiquer au serveur que je me suis connecté auparavant.

Semblable aux supermarchés qui gèrent les cartes de membre pour les clients, le caissier utilise la carte de membre pour confirmer si le client est un VIP

• La méthode d'authentification par carte de membre dans la vraie vie, le terme professionnel en développement web s'appelle Cookie

que sont les cookies

1. Un cookie est une chaîne de caractères stockée dans le navigateur de l'utilisateur qui ne dépasse généralement pas 4 Ko. Il se compose d'un nom (Name), d'une valeur (Value) et de plusieurs autres options permettant de contrôler la durée de validité, la sécurité et l'étendue de l'utilisation. du cookie composition des attributs

2. Les cookies sous différents noms de domaine sont indépendants.Chaque fois que le client initie une demande , tous les cookies non expirés sous le nom de domaine actuel seront automatiquement envoyés ensemble au serveur.

Plusieurs caractéristiques des cookies

Envoyé automatiquement, automatiquement comme demandé

Le nom de domaine est indépendant et Baidu ne peut pas accéder aux cookies sous Taobao

Délai d'expiration, chaque cookie a une date d'expiration, après laquelle il ne sera plus envoyé

Limite de 4 Ko, chaque cookie ne peut pas dépasser 4 Ko

Le rôle des cookies dans l'authentification de l'identité

1. Lorsque le client sollicite le serveur pour la première fois, le serveur envoie un cookie d'authentification au client sous la forme d'un en-tête de réponse

2. Le client enregistrera automatiquement le cookie dans le navigateur

3. Par la suite, chaque fois que le navigateur client demande au serveur, le navigateur enverra automatiquement tous les cookies liés à l'authentification de l'identité au serveur sous la forme d'en-têtes de requête.

4. Le serveur peut vérifier l'identité du client

Les cookies ne sont pas sécurisés

Étant donné que les cookies sont stockés dans le navigateur et que le navigateur fournit également des API pour lire et écrire des cookies, les cookies sont faciles à falsifier et ne sont pas sécurisés.

Par conséquent, il n'est pas recommandé que le serveur envoie des données privées importantes au navigateur sous la forme de cookies.

Par conséquent, n'utilisez jamais de cookies pour stocker des données importantes et privées, telles que les informations d'identité et les mots de passe de l'utilisateur.

Améliorer la sécurité de l'authentification d'identité

• De même, afin d'empêcher les clients de contrefaire des cartes de membre, le caissier peut passer la carte pour authentification sur la caisse après avoir reçu la carte de membre présentée par le client.Seule la carte de membre confirmée par la caisse enregistreuse peut être utilisée normalement, c'est-à-dire , carte de membre + lecteur de carte certifié
• Le concept de « carte de membre + authentification par carte » est l'essence même du mécanisme d'authentification de Session.

Comment fonctionnent les séances

Utilisation de l'authentification de session dans Express

• Installer le middleware Express-session, npm i express-session

Dans le projet Express, il vous suffit d'installer le middleware pour utiliser l'authentification de session dans le projet

• Configurer le middleware de session express

Une fois le middleware de session express installé avec succès, vous devez enregistrer le middleware de session via app.use()

//express-session中间件
//导入session中间件
const session = require('express-session')
//注册session
app.use(session({
    
    
    secret: "key", //值，负责对session加密
    resave: false, //固定写法
    saveUninitialized: true, //固定写法
}))

• Enregistrer les données dans la session

• Une fois la configuration réussie, l'objet de session peut être consulté et utilisé via req.session pour stocker les informations clés de l'utilisateur.
• Ce n'est que lorsque le middleware de session express est configuré que l'attribut de session peut être affiché via req
• Si la demande de publication, configurez cette application.use(express.urlencoded({extended:false})), sinon la demande de publication est vide

//express-session中间件
//导入session中间件
const session = require('express-session')
// 导入express
const express = require('express')
// 创建web服务器
const app = express()
// 启动文本服务器
app.listen(80,()=>{
    
    
    console.log("80服务器启动")
})
//注册session
app.use(session({
    
    
    secret: "key", //值，负责对session加密
    resave: false, //固定写法
    saveUninitialized: true, //固定写法
}))
//配置这个，不然post请求是空
app.post('/login', (req, res) => {
    
    
    if (req.body.name !== '乞力马扎罗' || req.body.password !== '111111') {
    
    
        return res.send({
    
    
            'status': 0,
            msg: "登录失败"
        })
    }
    //只有配置了express-session这个中间件，才能通过req点出来session这个属性
    //通过 req.session追加任何属性
    req.session.user = req.body
    req.session.islogin = true
    res.send({
    
    
        'status': 1,
        msg: "登录成功"
    })
})

• Récupérer les données de la session

//向session中取数据 
app.post('/getuserinfo', (req, res) => {
    
    
    console.log(req.session.user)
    // 判断用户是否登录
    if (!req.session.islogin) {
    
    
        res.send({
    
    
            'status': 0,
            msg: "请登录"
        })
        return
    }
    res.send({
    
    'status':1, data:req.session.user})
})

• séance claire

• Appelez la fonction req.session.destroy() pour effacer les informations de session enregistrées par le serveur.
• Cela n'effacera que les informations de session de l'utilisateur actuel qui l'utilise, au lieu d'effacer toutes les informations de session
• Appelez la scène, déconnectez-vous

app.post('/outlogin', (req, res) => {
    
    
    req.session.destroy()
    res.send({
    
    'status':1, msg:'退出成功'})
})

Limites du mécanisme d'authentification de session

• Le mécanisme d'authentification de session doit coopérer avec Cookie pour réaliser
• Étant donné que les cookies ne prennent pas en charge l'accès inter-domaines par défaut, lorsqu'il s'agit de requêtes inter-domaines frontales vers des interfaces back-end, de nombreuses configurations supplémentaires sont nécessaires.
• Afin d'obtenir une authentification de session interdomaine
• Avis:
• Lorsque le front-end demande l'interface back-end et qu'il n'y a pas de problème inter-domaines, il est recommandé d'utiliser le mécanisme d'authentification de session
• Lorsque le front-end doit demander l'interface back-end sur plusieurs domaines, il n'est pas recommandé d'utiliser le mécanisme d'authentification Seesion, et il est recommandé d'utiliser le mécanisme d'authentification JWT

Mécanisme d'authentification JWT

JWT, nom complet : JSON Web Token, est actuellement la solution d'authentification inter-domaines la plus populaire.

Comment fonctionnent les JWT

Composants de JWT

• JWT se compose généralement de trois parties, à savoir l'en-tête (tête), la charge utile (charge utile), la signature (signature)
• Les trois sont reliés par les Anglais.
• Format : En-tête.Charge utile.Signature
• La partie Payload est la véritable information de l'utilisateur, qui est une chaîne générée après le cryptage de l'information de l'utilisateur
• La partie En-tête et la partie Signature sont des parties liées à la sécurité, juste pour assurer la sécurité du jeton
• Le chemin de requête commençant par /api ne nécessite pas de droits d'accès
• Le chemin de la demande commençant par /my doit porter l'authentification d'identité d'autorisation dans l'en-tête de la demande, afin que l'accès normal puisse réussir

Authorization: Bearer <token>

Utilisation de JWT dans Express

• Installer les packages liés à JWT

npm install jsonwebtoken express-jwt

• jsonwebtoken est utilisé pour générer une chaîne JWT
• express-jwt est utilisé pour analyser et restaurer des chaînes JWT dans des objets JSON
• importer un paquet

const jwt = require("jsonwebtoken")
const expressjwt = require("express-jwt")

Définir la clé secrète

• Afin d'assurer la sécurité de la chaîne JWT et d'empêcher le JWT d'être piraté par d'autres lors de l'échec de la transmission réseau, nous devons définir une clé Secert pour le chiffrement et le déchiffrement.
• Lors de la génération de la chaîne JWT, vous devez utiliser la clé secrète pour chiffrer les informations de l'utilisateur, et enfin attendre que la chaîne JWT chiffrée
• Lors de l'analyse et de la restauration de la chaîne JWT dans un objet JSON, la clé serect est requise pour le déchiffrement

Générer une chaîne JWT après une connexion réussie

const jwt = require("jsonwebtoken")
const {
    
    expressjwt} = require("express-jwt")
//定义secret秘钥，
const secretKey="adminpossword"
app.post('/jwtlogin', (req, res) => {
    
    
	let user=req.body
    if (req.body.name !== '乞力马扎罗' || req.body.password !== '111111') {
    
    
        return res.send({
    
    
            'status': 0,
            msg: "登录失败"
        })
    }
    //调用jwt.sign()生成JWT字符串，三个参数分别是，用户信息对象，加密秘钥，配置对象（expiresIn代表token有效期）
    res.send({
    
    
        'status': 1,
        msg: "登录成功",
        token:jwt.sign(user,secretKey,{
    
    expiresIn:'30s'})
    })
})

Rétablir la chaîne JWT en objet JSON

• Chaque fois que le client accède à une interface autorisée, il doit passer activement le champ AUthirization dans l'en-tête de la requête pour envoyer la chaîne de jeton au serveur pour authentification.
• À ce moment, le serveur analyse et restaure automatiquement le jeton envoyé par le client dans un objet JSON via le middleware express.Jwt

// 1,使用app.use()注册
// 2，expressjwt({secret:secretKey})就是用来解析的中间件
// 3，.unless({path:[/^\/api\//]})用来指定哪些接口不需要访问权限
//4,algorithms:['HS256']必写
// 配置过 express-jwt 可通过 req.auth 获取token信息
app.use(expressjwt({
    
     secret: secretKey, algorithms: ["HS256"] }).unless({
    
     path: [/^\/api\//]}))

Accéder aux informations utilisateur analysées à partir de la chaîne JWT via l'objet req.user

• En-tête de requête de configuration Autorisation : Porteur+espace+token après connexion
• L'application ci-dessus app.use(expressjwt({ secret : secretKey, algorithms : [“HS256”] }).unless({ path: [/^/api//]}) doit être configuré globalement avant d'accéder

app.post('/getuser', (req, res) => {
    
    
    console.log(req.user) 
    res.send({
    
    
        status: 1,
        msg: "成功",
        data:req.auth
    })
}) 

Erreurs de capture générées après l'échec de l'analyse de JWT

• Vérifiez que le jeton est expiré ou illégal, et capturez ce problème via le middleware d'erreur express
• Le middleware d'erreur doit être placé après toutes les routes

//错误中间件
app.use((err, req, res, next) => {
    
    
    console.log(err)
    if (err.name === 'UnauthorizedError') {
    
    
        return res.send({
    
    
            status: 401,
            message: "无效token"
        })
    }
    res.send({
    
    
        status: 500,
        message: "未知错误"
    })
})