Best Practices für die Authentifizierung mit JWT in Go

Mit der Popularität von Webanwendungen und der Erweiterung ihres Anwendungsbereichs wird es immer wichtiger, Benutzerdaten und Identitätsinformationen zu schützen. Die Authentifizierung in Anwendungen ist sehr wichtig. In diesem Artikel werden die Best Practices für die Verwendung von JWT zur Implementierung der Authentifizierung in der Go-Sprache vorgestellt.

Was ist JWT?

JWT ist die Abkürzung für JSON Web Token. Es handelt sich um einen Authentifizierungsmechanismus, der Informationen sicher übertragen kann, ohne dass Speichermethoden wie Cookies erforderlich sind.

Ein JWT besteht aus drei Teilen:

• Header: Enthält Informationen wie Algorithmus und Typ.
• Payload: Speichert die zu übergebenden Benutzerinformationen wie Benutzername, ID usw.
• Signatur: Die durch Header, Payload und Schlüssel generierte Signatur stellt sicher, dass das JWT nicht manipuliert wurde.

Wenn sich der Benutzer anmeldet, überprüft der Server die Informationen des Benutzers. Wenn sie erfolgreich sind, generiert der Server ein JWT und gibt es an den Client zurück. Wenn der Client erneut auf andere Ressourcen zugreift, muss er das JWT übertragen Server zur Identifizierung des Benutzers, wodurch die Notwendigkeit vermieden wird, die Sitzung für jede Anfrage zu authentifizieren und zu speichern.

So verwenden Sie JWT, um die Authentifizierung in der Go-Sprache zu implementieren

Installation

Um JWT zu verwenden, müssen Sie entsprechende Pakete installieren. In der Go-Sprache wird offiziell das Paket github.com/dgrijalva/jwt-go bereitgestellt, das einfach verwendet werden kann. github.com/dgrijalva/jwt-go包，可以轻松使用。

go get github.com/dgrijalva/jwt-go

创建JWT令牌

我们可以使用以下代码创建JWT令牌

func createToken() string {
    token := jwt.New(jwt.SigningMethodHS256)
    claims := token.Claims.(jwt.MapClaims)
    claims["name"] = "张三"
    claims["exp"] = time.Now().Add(time.Hour * 24).Unix() // 1天过期
    tokenString, _ := token.SignedString([]byte("自定义密钥"))
    return tokenString
}

jwt.New(jwt.SigningMethodHS256)用于创建JWT令牌实例，其中jwt.SigningMethodHS256表示使用HS256算法。

令牌实例的Claims类型是一个map，通过向该map添加信息，可以在令牌中存储自定义的数据。进行身份验证时，可以获取Payload中的数据。

在Claims中，我们通过添加"name"和"exp"来定义了用户信息和过期时间，然后我们通过使用密钥进行签名生成了JWT令牌。

解析JWT令牌

当客户端向服务端发送JWT令牌时，服务端需要检查JWT令牌的有效性并解析获取用户信息。

func parseToken(tokenString string) {
    token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
        if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
            return nil, fmt.Errorf("预期的签名方法不正确：%v", token.Header["alg"])
        }
        return []byte("自定义密钥"), nil
    })
    if err != nil {
        fmt.Println("JWT解析失败")
        return
    }
    if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
        fmt.Println(claims["name"], claims["exp"])
    } else {
        fmt.Println("无效的JWT令牌")
    }
}

在代码中，强制类型转换token.Claims.(jwt.MapClaims)获得map形式的jwt.Claims，并进行验证。

我们还需要提供密钥（这里是"自定义密钥"）来验证签名，以确保传输过程中未被篡改。

如果JWT令牌验证通过，就可以从Claims中获取信息，包括存储在令牌中的自定义数据。

JWT使用实例

下面是一个完整的Go示例，展示创建JWT令牌和解析JWT令牌的完整过程。

package main

import (
    "fmt"
    "time"

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

func main() {
    // 创建JWT令牌
    token := jwt.New(jwt.SigningMethodHS256)
    claims := token.Claims.(jwt.MapClaims)
    claims["name"] = "张三"
    claims["exp"] = time.Now().Add(time.Hour * 24).Unix()

    // 签名密钥
    tokenString, _ := token.SignedString([]byte("自定义密钥"))
    fmt.Println("JWT创建成功", tokenString)

    // 解析JWT令牌
    token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
        if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
            return nil, fmt.Errorf("预期的签名方法不正确：%v", token.Header["alg"])
        }
        return []byte("自定义密钥"), nil
    })
    if err != nil {
        fmt.Println("JWT解析失败")
        return
    }
    if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
        fmt.Println("JWT解析成功", claims["name"], claims["exp"])
    } else {
        fmt.Println("无效的JWT令牌")
    }
}

总结

在Web应用程序中进行身份验证非常必要，使用JWT凭据可以减少服务端处理开销和提高性能，同时也是更加安全和可靠的身份验证机制。在Go语言中，使用JWT非常方便，通过相关的包github.com/dgrijalva/jwt-gorrreee

JWT-Token erstellen

Wir können den folgenden Code verwenden, um ein JWT-Token zu erstellen🎜rrreee🎜jwt.New(jwt.SigningMethodHS256) wird verwendet, um eine JWT-Token-Instanz zu erstellen, wobei jwt.SigningMethodHS256 bedeutet die Verwendung des HS256-Algorithmus. 🎜🎜Der Anspruchstyp einer Token-Instanz ist eine Karte. Benutzerdefinierte Daten können im Token gespeichert werden, indem Informationen zur Karte hinzugefügt werden. Bei der Authentifizierung können die Daten in der Payload abgerufen werden. 🎜🎜In Ansprüchen haben wir die Benutzerinformationen und die Ablaufzeit definiert, indem wir „Name“ und „Exp“ hinzugefügt haben, und dann haben wir das JWT-Token durch Signieren mit dem Schlüssel generiert. 🎜🎜JWT-Token analysieren🎜🎜Wenn der Client ein JWT-Token an den Server sendet, muss der Server die Gültigkeit des JWT-Tokens überprüfen und es analysieren, um Benutzerinformationen zu erhalten. 🎜rrreee🎜Führen Sie im Code die Typkonvertierung token.Claims.(jwt.MapClaims) aus, um jwt.Claims in Kartenform zu erhalten und zu überprüfen. 🎜🎜Wir müssen außerdem einen Schlüssel (hier „benutzerdefinierter Schlüssel“) bereitstellen, um die Signatur zu überprüfen und sicherzustellen, dass sie während der Übertragung nicht manipuliert wurde. 🎜🎜Wenn die JWT-Token-Überprüfung erfolgreich ist, können Sie Informationen aus Ansprüchen abrufen, einschließlich der im Token gespeicherten benutzerdefinierten Daten. 🎜🎜JWT-Nutzungsbeispiel🎜🎜Das Folgende ist ein vollständiges Go-Beispiel, das den gesamten Prozess der Erstellung von JWT-Tokens und des Parsens von JWT-Tokens zeigt. 🎜rrreee🎜Zusammenfassung🎜🎜Die Authentifizierung in Webanwendungen ist sehr wichtig. Die Verwendung von JWT-Anmeldeinformationen kann den serverseitigen Verarbeitungsaufwand reduzieren und die Leistung verbessern und ist außerdem ein sichererer und zuverlässigerer Authentifizierungsmechanismus. In der Go-Sprache ist es sehr praktisch, JWT zu verwenden, das einfach über das zugehörige Paket github.com/dgrijalva/jwt-go implementiert werden kann. 🎜🎜Kurz gesagt ist JWT eine sehr gute Authentifizierungsmethode. Die Verwendung von JWT kann die Sicherheit von Benutzerdaten und Identitätsinformationen schützen und die Leistung und Zuverlässigkeit von Webanwendungen verbessern. 🎜

Das obige ist der detaillierte Inhalt vonBest Practices für die Authentifizierung mit JWT in Go. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!