Der Knoten implementiert eine tokenbasierte Authentifizierung

Dieser Artikel stellt hauptsächlich die Implementierung der tokenbasierten Authentifizierung vor. Jetzt kann ich ihn mit allen teilen, die ihn benötigen.

Ich habe kürzlich die tokenbasierte Authentifizierung studiert und diesen Mechanismus eingeführt Projekte. Heutzutage hat sich die Authentifizierungsmethode vieler Websites von der traditionellen Sitzung+Cookie 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];
  });

});

Benutzer speichert den erhaltenen Token lokal durch Verifizierung:

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

Nachdem der Client eine angefordert hat Schnittstelle, die eine Identitätsüberprüfung erfordert, wird das Token im Anforderungsheader platziert, der an den Server übergeben wird:

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 das Legitimität aller Schnittstellen, die eine Anmeldung 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 = &#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();
  }
});

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, öffnen Sie 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 Knoten-Back-End-Code anzuzeigen
Klicken Sie hier, um den Front-End-Code anzuzeigen

Verwandte Empfehlungen:

Node.js-Modulsystem

Knotenerklärung und Durchführung der js-Prozessanalyse

Das obige ist der detaillierte Inhalt vonDer Knoten implementiert eine tokenbasierte Authentifizierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!