Utilisation de la bibliothèque jwt-go pour implémenter la vérification et l'authentification des jetons JWT en langage Go

Utilisez la bibliothèque jwt-go pour implémenter l'authentification par jeton JWT dans le langage Go

JWT (JSON Web Token) est une méthode d'authentification et d'autorisation légère qui peut nous aider à communiquer entre les utilisateurs et les systèmes basés sur le format JSON pour fournir des informations sécurisées et dignes de confiance. . Dans le processus de construction du jeton JWT, nous devons signer la charge utile, ce qui signifie également que lorsque nous analysons le jeton côté serveur, nous pouvons vérifier sa légitimité.

Nous pouvons utiliser la bibliothèque jwt-go en langage Go pour implémenter la fonction d'authentification du jeton JWT. La bibliothèque jwt-go fournit un moyen simple de générer, vérifier et analyser le jeton JWT. Le jeton JWT se compose de deux parties : l'en-tête et la charge utile, séparées par des points.

L'en-tête contient deux attributs alg (algorithme) et typ (type). L'algorithme peut utiliser HMAC, RSA ou certains autres algorithmes de chiffrement, et le type fait référence au type de jeton JWT. Sa valeur dans la norme est JWT.

La charge utile a également quelques attributs, mais ces attributs ne sont pas des attributs standard, mais des attributs personnalisés, utilisés pour la communication entre le serveur et le client.

Maintenant, examinons le processus de mise en œuvre spécifique.

Installer la bibliothèque dépendante

Avant de commencer à utiliser la bibliothèque jwt-go, nous devons d'abord l'installer. Vous pouvez utiliser la commande suivante pour l'installer :

go get github.com/dgrijalva/jwt-go

Importer la bibliothèque dépendante

Importer la bibliothèque jwt-go. dans le code :

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

Générer un jeton JWT

Pour générer un jeton JWT en langage Go, nous devons signer la charge utile. Le processus de signature nécessite l'utilisation d'une paire de clés publiques et privées. La clé publique est utilisée pour vérifier le. la légitimité du Token, et la clé privée est utilisée pour générer le Token. Nous pouvons enregistrer la clé privée dans le fichier de configuration ou la variable d'environnement pour assurer sa sécurité.

Ce qui suit est un exemple de génération d'un jeton JWT :

// 生成JWT Token
func GenerateJwtToken() (string, error) {
    // 加载私钥
    privateKeyByte, err := ioutil.ReadFile("jwtRS256.key")
    if err != nil {
        return "", err
    }
    privateKey, err := jwt.ParseRSAPrivateKeyFromPEM(privateKeyByte)
    if err != nil {
        return "", err
    }
    // 设置Payload
    claims := jwt.MapClaims{
        "username": "admin",
        "exp":      time.Now().Add(time.Hour * 24).Unix(), // 过期时间
    }
    // 生成JWT Token
    token := jwt.NewWithClaims(jwt.SigningMethodRS256, claims)
    tokenString, err := token.SignedString(privateKey)
    if err != nil {
        return "", err
    }
    // 返回生成的Token
    return tokenString, nil
}

Dans l'exemple ci-dessus, nous avons chargé une clé privée, puis défini la charge utile, utilisé la signature de clé privée pour générer un jeton JWT et finalement renvoyé le jeton JWT.

Vérifier le jeton JWT

Pour vérifier la légitimité du jeton JWT en langage Go, nous devons d'abord analyser la charge utile du jeton, puis utiliser la clé publique pour vérifier le jeton.

Ce qui suit est un exemple de vérification du jeton JWT :

// 验证JWT Token
func ParseJwtToken(tokenString string) (jwt.MapClaims, error) {
    // 加载公钥
    publicKeyByte, err := ioutil.ReadFile("jwtRS256.pem")
    if err != nil {
        return nil, err
    }
    publicKey, err := jwt.ParseRSAPublicKeyFromPEM(publicKeyByte)
    if err != nil {
        return nil, err
    }
    // 解析JWT Token
    token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
        _, ok := token.Method.(*jwt.SigningMethodRSA)
        if !ok {
            return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
        }
        return publicKey, nil
    })
    if err != nil {
        return nil, err
    }
    if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
        return claims, nil
    }
    return nil, fmt.Errorf("invalid token")
}

Dans l'exemple ci-dessus, nous avons chargé une clé publique, puis analysé un jeton JWT, utilisé la clé publique pour vérifier la légitimité du jeton JWT et finalement renvoyé la charge utile. .

Résumé

Utiliser la bibliothèque jwt-go pour implémenter l'authentification par jeton JWT en langage Go est un moyen simple et efficace. En tant que méthode légère d'authentification et d'autorisation, JWT Token peut transférer en toute sécurité des informations entre le serveur et le client. En utilisant la bibliothèque jwt-go, vous pouvez rapidement générer, vérifier et analyser le jeton JWT, et garantir la sécurité pendant le processus de transmission.

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!