le nœud implémente l'authentification basée sur un jeton

Cet article présente principalement le nœud pour implémenter l'authentification par jeton. Maintenant, je le partage avec tout le monde. Les amis dans le besoin peuvent s'y référer

J'ai récemment étudié l'authentification par jeton et introduit ce mécanisme intégré dans le personnel. projets. De nos jours, la méthode d'authentification de nombreux sites Web est passée du traditionnel seesion+cookie à la vérification par jeton. Par rapport aux méthodes de vérification traditionnelles, les jetons offrent une meilleure évolutivité et sécurité.

Session traditionnelle+authentification par cookie

Le HTTP étant sans état, il n'enregistre pas l'identité de l'utilisateur. Une fois que l'utilisateur a envoyé le compte et le mot de passe au serveur, l'arrière-plan réussit la vérification, mais le statut n'est pas enregistré, donc la demande de l'utilisateur suivant doit toujours vérifier l'identité. Afin de résoudre ce problème, il est nécessaire de générer un enregistrement contenant l'identité de l'utilisateur côté serveur, c'est-à-dire la session, puis d'envoyer cet enregistrement à l'utilisateur et de le stocker localement dans la zone locale de l'utilisateur, c'est-à-dire un cookie. . Ensuite, la demande de l'utilisateur apportera ce cookie. Si le cookie du client et la session du serveur peuvent correspondre, cela signifie que l'authentification de l'identité de l'utilisateur a réussi.

Vérification de l'identité du jeton

Le processus est à peu près le suivant :

1. Lors de la première demande, l'utilisateur envoie le numéro de compte et mot de passe

2. Si la vérification des antécédents réussit, un jeton sensible au temps sera généré et ce jeton sera envoyé à l'utilisateur

3. Une fois que l'utilisateur a obtenu le jeton, stockez ce jeton localement, généralement dans un stockage local ou un cookie

4. Chaque requête ultérieure ajoutera ce jeton à l'en-tête de la requête, ainsi qu'à toutes les interfaces qui en ont besoin. pour vérifier l'identité sera vérifiée. Vérifiez le jeton. Si les données analysées par le jeton contiennent des informations sur l'identité de l'utilisateur, la vérification de l'identité est réussie.

Par rapport aux méthodes de vérification traditionnelles, la vérification des jetons présente les avantages suivants :

1. Dans l'authentification basée sur les jetons, le jeton est transmis via la demande en-tête. Au lieu de stocker les informations d’authentification dans une session ou un cookie. Cela signifie apatride. Vous pouvez envoyer des requêtes au serveur à partir de n'importe quel terminal pouvant envoyer des requêtes HTTP.

2. Peut éviter les attaques CSRF

3. Lorsqu'une session est lue, écrite ou supprimée dans une application, une opération sur le fichier se produit dans le dossier temporaire de le système d’exploitation, au moins la première fois. Supposons qu'il existe plusieurs serveurs et que la session est créée sur le premier service. Lorsque vous renvoyez la demande et que celle-ci arrive sur un autre serveur, les informations de session n'existent pas et vous obtenez une réponse « non authentifiée ». Je sais, vous pouvez résoudre ce problème avec une session collante. Cependant, dans l’authentification basée sur les jetons, ce problème est naturellement résolu. Il n'y a pas de problème de session persistante car le jeton de requête est intercepté à chaque requête envoyée au serveur.

Ce qui suit est une introduction à l'utilisation de node+jwt (tutoriel jwt) pour créer une simple vérification d'identité de jeton

Exemple

Lorsque l'utilisateur se connecte pour la première fois, il soumet son compte et son mot de passe au serveur. Si le serveur réussit la vérification, le token correspondant est généré :

.

const fs = require('fs');
const path = require('path');
const jwt = require('jsonwebtoken');
//生成token的方法
function generateToken(data){
  let created = Math.floor(Date.now() / 1000);
  let cert = fs.readFileSync(path.join(__dirname, '../config/pri.pem'));//私钥
  let token = jwt.sign({
    data,
    exp: created + 3600 * 24
  }, cert, {algorithm: 'RS256'});
  return token;
}

//登录接口
router.post('/oa/login', async (ctx, next) => {
  let data = ctx.request.body；
  let {name, password} = data;
  let sql = 'SELECT uid FROM t_user WHERE name=? and password=? and is_delete=0', value = [name, md5(password)];
  await db.query(sql, value).then(res => {
    if (res && res.length > 0) {
      let val = res[0];
      let uid = val['uid'];
      let token = generateToken({uid});
      ctx.body = {
        ...Tips[0], data: {token}
      }
    } else {
      ctx.body = Tips[1006];
    }
  }).catch(e => {
    ctx.body = Tips[1002];
  });

});

Utilisateur Stockez le jeton obtenu localement par vérification :

store.set('loginedtoken',token);//store为插件

Une fois que le client a demandé une interface qui nécessite vérification de l'identité, le token sera placé dans l'en-tête de la requête transmis au serveur :

service.interceptors.request.use(config => {
  let params = config.params || {};
  let loginedtoken = store.get('loginedtoken');
  let time = Date.now();
  let {headers} = config;
  headers = {...headers,loginedtoken};
  params = {...params,_:time};
  config = {...config,params,headers};
  return config;
}, error => {
  Promise.reject(error);
})

Le serveur intercepte le token et vérifie la légitimité de tous. interfaces qui nécessitent une connexion.

function verifyToken(token){
  let cert = fs.readFileSync(path.join(__dirname, '../config/pub.pem'));//公钥
  try{
    let result = jwt.verify(token, cert, {algorithms: ['RS256']}) || {};
    let {exp = 0} = result,current = Math.floor(Date.now()/1000);
    if(current <= exp){
      res = result.data || {};
    }
  }catch(e){

  }
  return res;

}

app.use(async(ctx, next) => {
  let {url = &#39;&#39;} = ctx;
  if(url.indexOf(&#39;/user/&#39;) > -1){//需要校验登录态
    let header = ctx.request.header;
    let {loginedtoken} = header;
    if (loginedtoken) {
      let result = verifyToken(loginedtoken);
      let {uid} = result;
      if(uid){
        ctx.state = {uid};
        await next();
      }else{
        return ctx.body = Tips[1005];
      }
    } else {
      return ctx.body = Tips[1005];
    }
  }else{
    await next();
  }
});

Les clés publiques et privées utilisées dans cet exemple peuvent être générées par vous-même. Le fonctionnement est le suivant :

1. Ouvrez l'outil de ligne de commande, entrez openssl, ouvrez openssl ;

2. Générez la clé privée : genrsa -out rsa_private_key.pem 2048

3. Générer une clé publique : rsa -in rsa_private_key.pem -pubout -out rsa_public_key.pem

Cliquez ici pour afficher le code backend du nœud
Cliquez ici ici pour voir le code front-end

Recommandations associées :

Système de modules Node.js

explication et exécution des nœuds d'analyse des processus js

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!