So verwenden Sie JWT zur Implementierung der OAuth2.0-Authentifizierung im Golang-Projekt

Mit der rasanten Entwicklung des Internets müssen immer mehr Anwendungen Benutzerauthentifizierung und -autorisierung implementieren. OAuth2.0 ist eines der beliebtesten Autorisierungsframeworks und wird häufig in Web- und Mobilanwendungen verwendet. JWT (JSON Web Token) ist ein weit verbreiteter Authentifizierungsstandard, der es Entwicklern ermöglicht, Informationen sicher zwischen Clients und Servern zu übertragen. Es ist sehr einfach, JWT zur Implementierung der OAuth2.0-Authentifizierung in Golang-Projekten zu verwenden. Im Folgenden stellen wir vor, wie Sie es implementieren.

1. JWT-Bibliothek installieren

Bevor Sie JWT verwenden, müssen Sie die jwt-go-Bibliothek unter Golang installieren. Verwenden Sie den folgenden Befehl, um die Installation abzuschließen.

go get github.com/dgrijalva/jwt-go

2. JWT-Authentifizierungsprozess

Bevor wir uns vorstellen, wie man JWT zur Implementierung der OAuth2.0-Authentifizierung verwendet, machen wir uns zunächst mit den Grundkonzepten und Arbeitsprinzipien von JWT vertraut. Als Standardauthentifizierungsmethode weist JWT die folgenden Merkmale auf:

• besteht aus drei Teilen: Header, Payload und Signatur
• Die Kodierungsmethode ist Base64Url-Kodierung
• Sie kann in einer domänenübergreifenden Umgebung verwendet werden. Der Authentifizierungsprozess dient der Sicherheit Das Übertragen von Daten

JWT ist wie folgt:

• Der Client sendet eine Anfrage
• Der Server überprüft die vom Client angeforderten Informationen, generiert ein JWT-Token und gibt es an den Client zurück
• Der Client sendet das gespeicherte JWT-Token Lokal wird jedes Mal, wenn eine Anfrage gesendet wird, das JWT-Token als Autorisierungsheader an den Server gesendet. Der Server empfängt die Anfrage, überprüft, ob das JWT-Token gültig ist, und gibt das Anfrageergebnis zurück, wenn es gültig ist. Andernfalls wird ein Fehler zurückgegeben Nachricht

JWT-Authentifizierung implementieren

Um JWT zur Implementierung der OAuth2.0-Authentifizierung im Golang-Projekt zu verwenden, müssen Sie die folgenden Schritte ausführen:

JWT-Token erstellen

• JWT-Token überprüfen
Wir werden Ihnen vorstellen, wie um es der Reihe nach unten zu erledigen.

3.1 JWT-Token erstellen

Beim Generieren eines JWT-Tokens auf der Serverseite müssen Sie drei Parameter festlegen: Schlüssel, Nutzlastinformationen (Claims) und Ablaufzeit (ExpiresAt).

Verwenden Sie den folgenden Code, um ein JWT-Token zu erstellen:

import (
    "github.com/dgrijalva/jwt-go"
)

func CreateJWT() (string, error) {
    // 设置密钥
    secret := []byte("secret")

    // 设置载荷信息
    token := jwt.New(jwt.SigningMethodHS256)
    claims := token.Claims.(jwt.MapClaims)
    claims["authorized"] = true
    claims["user_id"] = 1
    claims["exp"] = time.Now().Add(time.Minute * 30).Unix()

    // 创建JWT令牌
    tokenString, err := token.SignedString(secret)
    if err != nil {
        return "", err
    }

    return tokenString, nil
}

Im obigen Code setzen wir den Schlüssel auf „geheim“, und die Nutzlastinformationen umfassen den Benutzerautorisierungsstatus, die Benutzer-ID und die Ablaufzeit. Erstellen Sie abschließend das JWT-Token mit der token.SignedString-Methode.

3.2 JWT-Token überprüfen

Wenn der Client eine Anfrage sendet, muss das JWT-Token lokal gespeichert und in jeder Anfrage als Autorisierungsheader an den Server gesendet werden. Nach Erhalt der Anfrage muss der Server die Gültigkeit des JWT-Tokens überprüfen.

Das JWT-Token kann mit dem folgenden Code überprüft werden:

import (
    "github.com/dgrijalva/jwt-go"
)

func VerifyJWT(tokenString string) (jwt.MapClaims, error) {
    // 设置密钥
    secret := []byte("secret")

    // 解析JWT令牌
    token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
        if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
            return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
        }

        return secret, nil
    })

    if err != nil {
        return nil, err
    }

    // 校验JWT令牌
    if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
        return claims, nil
    }

    return nil, fmt.Errorf("invalid token")
}

Im obigen Code setzen wir das Geheimnis auf „geheim“, verwenden die Methode jwt.Parse, um das JWT-Token zu analysieren, und verwenden token.Claims.(jwt .MapClaims) Konvertieren Sie Nutzlastinformationen in den MapClaims-Typ. Abschließend überprüfen wir, ob das JWT-Token gültig ist.

Fazit

4. Die Verwendung von JWT zur Implementierung der OAuth2.0-Authentifizierung in Golang-Projekten ist sehr einfach, Sie müssen nur die beiden oben genannten Schritte ausführen. Als Standardauthentifizierungsmethode verfügt JWT über eine hervorragende domänenübergreifende Leistung und Sicherheit. Es kann uns eine effiziente, sichere und bequeme Authentifizierungsmethode bieten, die die Entwicklungseffizienz und das Benutzererlebnis erheblich verbessert.

Das obige ist der detaillierte Inhalt vonSo verwenden Sie JWT zur Implementierung der OAuth2.0-Authentifizierung im Golang-Projekt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!