Knoten+Token führt eine Benutzerüberprüfung durch

Dieses Mal bringe ich Ihnen Node+Token zur Benutzerüberprüfung. Was sind die Vorsichtsmaßnahmen für Node+Token zur Benutzerüberprüfung? Hier ist ein praktischer Fall, schauen wir uns das an.

Kürzlich habe ich mich mit der tokenbasierten Authentifizierung befasst und diesen Mechanismus in mein persönliches Projekt integriert. Heutzutage hat sich die Authentifizierungsmethode vieler Websites von der traditionellen Seesion+Cookie-Methode zur Token-Verifizierung verlagert. Im Vergleich zu herkömmlichen Verifizierungsmethoden weisen Token eine bessere Skalierbarkeit und Sicherheit auf.

Herkömmliche Sitzungs- und Cookie-Authentifizierung

Da HTTP zustandslos ist, wird die Identität des Benutzers nicht aufgezeichnet. Nachdem der Benutzer das Konto und das Kennwort an den Server gesendet hat, besteht der Hintergrund die Überprüfung, der Status wird jedoch nicht aufgezeichnet, sodass die nächste Benutzeranforderung weiterhin die Identität überprüfen muss. Um dieses Problem zu lösen, ist es notwendig, auf der Serverseite einen Datensatz zu generieren, der die Identität des Benutzers, also die Sitzung, enthält, diesen Datensatz dann an den Benutzer zu senden und ihn lokal im lokalen Bereich des Benutzers, also als Cookie, zu speichern . Als nächstes bringt die Anfrage des Benutzers dieses Cookie. Wenn das Cookie des Clients und die Sitzung des Servers übereinstimmen, bedeutet dies, dass die Identitätsauthentifizierung des Benutzers erfolgreich war.

Token-Identitätsüberprüfung

Der Prozess ist ungefähr wie folgt:

1. Bei der ersten Anfrage sendet der Benutzer die Kontonummer und Passwort

2. Wenn die Hintergrundüberprüfung erfolgreich ist, wird ein zeitkritisches Token generiert und dieses Token wird an den Benutzer gesendet

3. Nachdem der Benutzer das Token erhalten hat, speichern Sie dieses Token lokal, normalerweise im lokalen Speicher oder im Cookie

4. Bei jeder weiteren Anfrage wird dieses Token zum Anfrageheader und allen benötigten Schnittstellen hinzugefügt Um die Identität zu überprüfen, wird das Token überprüft. Wenn die vom Token analysierten Daten Informationen zur Benutzeridentität enthalten, wird die Identitätsüberprüfung bestanden.

Im Vergleich zu herkömmlichen Verifizierungsmethoden bietet die Token-Verifizierung folgende Vorteile:

1. Bei der tokenbasierten Authentifizierung wird das Token durch die Anfrage übermittelt Header, anstatt Authentifizierungsinformationen in der Sitzung oder im Cookie zu speichern. Das bedeutet staatenlos. Sie können von jedem Terminal, das HTTP-Anfragen senden kann, Anfragen an den Server senden.

2. Kann CSRF-Angriffe vermeiden

3. Wenn eine Sitzung in einer Anwendung gelesen, geschrieben oder gelöscht wird, erfolgt ein Dateivorgang im temporären Ordner von das Betriebssystem, zumindest beim ersten Mal. Angenommen, es gibt mehrere Server und die Sitzung wird auf dem ersten Dienst erstellt. Wenn Sie die Anfrage erneut senden und die Anfrage auf einem anderen Server landet, sind die Sitzungsinformationen nicht vorhanden und Sie erhalten eine „nicht authentifizierte“ Antwort. Ich weiß, dass Sie dieses Problem mit einer Sticky Session lösen können. Bei der tokenbasierten Authentifizierung wird dieses Problem jedoch natürlich gelöst. Es gibt kein Sticky-Session-Problem, da das Anforderungstoken bei jeder an den Server gesendeten Anforderung abgefangen wird.

Das Folgende ist eine Einführung in die Verwendung von Node+JWT (JWT-Tutorial) zum Erstellen einer einfachen Token-Identitätsüberprüfung

Beispiel

Wenn sich der Benutzer zum ersten Mal anmeldet, übermittelt er das Konto und das Passwort an den Server. Wenn der Server die Überprüfung besteht, wird der entsprechende Code wie folgt generiert:

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];
  });
});

Der Benutzer besteht die Überprüfung und speichert das Token lokal:

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

Nachdem der Client eine Schnittstelle angefordert hat, die eine Identitätsüberprüfung erfordert, fügt er das Token in den Anforderungsheader ein und übergibt es an den Server:

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);
})

Der Server fängt das Token ab und überprüft, ob es für alle Schnittstellen legal ist, die Login-Sex erfordern.

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 = ''} = 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();
  }
});

Die in diesem Beispiel verwendeten öffentlichen und privaten Schlüssel können Sie selbst generieren. Der Vorgang ist wie folgt:

1. Öffnen Sie das Befehlszeilentool, geben Sie openssl ein und öffnen Sie es openssl;

2. Privaten Schlüssel generieren: genrsa -out rsa_private_key.pem 2048

3. Öffentlichen Schlüssel generieren: rsa -in rsa_private_key.pem -pubout - out rsa_public_key.pem

Ich glaube, dass Sie die Methode beherrschen, nachdem Sie den Fall in diesem Artikel gelesen haben. Weitere spannende Informationen finden Sie in anderen verwandten Artikeln auf der chinesischen PHP-Website!

Empfohlene Lektüre:

React, Redux, React-Redux verwenden

Detaillierte Erläuterung des Falles der Verwendung ausgewählter Komponenten

Das obige ist der detaillierte Inhalt vonKnoten+Token führt eine Benutzerüberprüfung durch. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!