Bonnes pratiques pour l'authentification à l'aide de JWT dans Go

Avec la popularité des applications Web et l'expansion de leur champ d'application, il est de plus en plus important de protéger les données des utilisateurs et les informations d'identité. L'authentification dans les applications est très nécessaire. Cet article présentera les meilleures pratiques sur la façon d'utiliser JWT pour implémenter l'authentification en langage Go.

Qu'est-ce que JWT

JWT est l'abréviation de JSON Web Token. Il s'agit d'un mécanisme d'authentification qui peut transmettre des informations en toute sécurité sans nécessiter de méthodes de stockage telles que les cookies.

Un JWT se compose de trois parties :

• En-tête : contient des informations telles que l'algorithme et le type.
• Payload : stocke les informations utilisateur à transmettre, telles que le nom d'utilisateur, l'identifiant, etc.
• Signature : la signature générée par l'en-tête, la charge utile et la clé garantit que le JWT n'a pas été falsifié.

Lorsque l'utilisateur se connectera, le serveur vérifiera les informations de l'utilisateur. Si cela réussit, le serveur générera un JWT et le renverra au client. Lorsque le client accédera à nouveau à d'autres ressources, il devra transporter le JWT pour le client. serveur pour identifier l'utilisateur, cela évite d'avoir à authentifier et à stocker la session pour chaque demande.

Comment utiliser JWT pour implémenter l'authentification en langage Go

Installation

Pour utiliser JWT, vous devez installer les packages associés. Dans le langage Go, le package github.com/dgrijalva/jwt-go est officiellement fourni, qui peut être facilement utilisé. 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

Créer un jeton JWT

Nous pouvons utiliser le code suivant pour créer un jeton JWT🎜rrreee🎜jwt.New(jwt.SigningMethodHS256) est utilisé pour créer une instance de jeton JWT, où jwt.SigningMethodHS256 signifie en utilisant l'algorithme HS256. 🎜🎜Le type de réclamation d'une instance de jeton est une carte. Des données personnalisées peuvent être stockées dans le jeton en ajoutant des informations à la carte. Lors de l'authentification, les données de la charge utile peuvent être obtenues. 🎜🎜Dans Claims, nous avons défini les informations utilisateur et le délai d'expiration en ajoutant "name" et "exp", puis nous avons généré le jeton JWT en signant avec la clé. 🎜🎜Analyser le jeton JWT🎜🎜Lorsque le client envoie un jeton JWT au serveur, le serveur doit vérifier la validité du jeton JWT et l'analyser pour obtenir des informations sur l'utilisateur. 🎜rrreee🎜Dans le code, lancez token.Claims.(jwt.MapClaims) pour obtenir jwt.Claims sous forme de carte et vérifiez-le. 🎜🎜Nous devons également fournir une clé (ici « clé personnalisée ») pour vérifier la signature afin de nous assurer qu'elle n'a pas été falsifiée lors de la transmission. 🎜🎜Si la vérification du jeton JWT réussit, vous pouvez obtenir des informations à partir des réclamations, y compris les données personnalisées stockées dans le jeton. 🎜🎜Exemple d'utilisation de JWT🎜🎜Ce qui suit est un exemple Go complet montrant le processus complet de création de jetons JWT et d'analyse des jetons JWT. 🎜rrreee🎜Résumé🎜🎜L'authentification dans les applications Web est très nécessaire. L'utilisation des informations d'identification JWT peut réduire la surcharge de traitement côté serveur et améliorer les performances, et constitue également un mécanisme d'authentification plus sécurisé et fiable. Dans le langage Go, il est très pratique d'utiliser JWT, qui peut être facilement implémenté via le package associé github.com/dgrijalva/jwt-go. 🎜🎜En bref, JWT est une très bonne méthode d'authentification. L'utilisation de JWT peut protéger la sécurité des données utilisateur et des informations d'identité, et améliorer les performances et la fiabilité des applications Web. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!