Knoten+Token implementiert die Verifizierung

Dieses Mal werde ich Ihnen die Vorsichtsmaßnahmen für die Überprüfung der Knoten+Token-Implementierung vorstellen.

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

Klicken Sie hier, um den Node-Back-End-Code anzuzeigen

Klicken Sie hier, um den Front-End-Code anzuzeigen

Ich glaube, Sie haben das gemeistert Lesen Sie den Fall in diesem Artikel, um mehr über die Methode zu erfahren. Weitere spannende Informationen finden Sie auf anderen chinesischen PHP-Websites. Verwandte Artikel!

Empfohlene Lektüre:

Detaillierte Erläuterung der Codeaufteilung zur Optimierung der Vue-Paketierungsschritte

Vue2-Routing-Navigation und Axios-Interceptor-Paketierung

Das obige ist der detaillierte Inhalt vonKnoten+Token implementiert die Verifizierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!