Comment utiliser Node pour implémenter l'authentification basée sur un jeton

Cette fois, je vais vous montrer comment utiliser Node pour implémenter l'authentification basée sur un jeton. Quelles sont les précautions concernant l'utilisation de Node pour implémenter l'authentification basée sur un jeton. Voici des cas pratiques, jetons un coup d'œil.

Récemment, j'ai étudié l'authentification basée sur les jetons et j'ai intégré ce mécanisme dans mon projet personnel. 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 apatride, 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 le compte et le mot de passe au serveur. Si le serveur réussit la vérification, le jeton 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];
  });
});

<.>L'utilisateur réussit la vérification et stocke le jeton localement :

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

Une fois que le client a demandé une interface qui nécessite une vérification d'identité, il placera le jeton dans l'en-tête de la demande et le transmettra 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 demandera toutes les interfaces qui nécessitent une connexion intercepter le jeton et vérifiera sa légitimité.

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  {
  let {url = ''} = ctx;
  if(url.indexOf('/user/') > -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();
  }
});

La clé publique et la clé privée 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, saisissez. openssl, open openssl;

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

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

Je pense que vous maîtrisez la méthode après avoir lu le cas dans cet article. Pour des informations plus intéressantes, veuillez prêter attention aux autres articles connexes sur le php chinois. site web!

Lecture recommandée :

Explication détaillée des étapes pour utiliser scss dans les projets angulaires

Comment utiliser vue2.0 +koa2+mongodb pour implémenter S'inscrire et se connecter

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!