Comment utiliser JWT pour implémenter l'authentification OAuth2.0 dans le projet Golang

Avec le développement rapide d'Internet, de plus en plus d'applications doivent mettre en œuvre l'authentification et l'autorisation des utilisateurs. OAuth2.0, l'un des cadres d'autorisation les plus populaires, est largement utilisé dans les applications Web et mobiles. JWT (JSON Web Token) est une norme d'authentification largement utilisée qui permet aux développeurs de transmettre en toute sécurité des informations entre clients et serveurs. Il est très simple d'utiliser JWT pour implémenter l'authentification OAuth2.0 dans les projets Golang. Nous expliquerons ci-dessous comment l'implémenter.

1. Installer la bibliothèque JWT

Avant d'utiliser JWT, vous devez installer la bibliothèque jwt-go sous Golang. Utilisez la commande suivante pour terminer l'installation.

go get github.com/dgrijalva/jwt-go

2. Processus d'authentification JWT

Avant de présenter comment utiliser JWT pour implémenter l'authentification OAuth2.0, familiarisons-nous d'abord avec les concepts de base et les principes de fonctionnement de JWT. En tant que méthode d'authentification standard, JWT présente les caractéristiques suivantes :

• se compose de trois parties : en-tête, charge utile et signature
• La méthode d'encodage est l'encodage Base64Url
• Elle peut être utilisée dans un environnement multi-domaines Le processus d'authentification pour une utilisation sécurisée la transmission des données

JWT est la suivante :

• Le client envoie une requête
• Le serveur vérifie les informations demandées par le client, génère un jeton JWT et le renvoie au client
• Le client envoie le jeton JWT stocké localement, chaque fois qu'une requête est envoyée, le jeton JWT est envoyé au serveur en tant qu'en-tête d'autorisation
• Le serveur reçoit la requête, vérifie si le jeton JWT est valide et renvoie le résultat de la requête s'il est valide, sinon il renvoie une erreur message

3. Implémenter l'authentification JWT

Pour utiliser JWT pour implémenter l'authentification OAuth2.0 dans le projet Golang, vous devez suivre les étapes suivantes :

• Créer un jeton JWT
• Vérifier le jeton JWT

Nous présenterons comment pour le faire à tour de rôle ci-dessous accomplir.

3.1 Créer un jeton JWT

Lors de la génération d'un jeton JWT côté serveur, vous devez définir trois paramètres : la clé, les informations de charge utile (Claims) et le délai d'expiration (ExpiresAt).

Utilisez le code suivant pour créer un jeton JWT :

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
}

Dans le code ci-dessus, nous définissons la clé sur "secret", et les informations de charge utile incluent le statut d'autorisation de l'utilisateur, l'ID utilisateur et le délai d'expiration. Créez enfin le jeton JWT à l’aide de la méthode token.SignedString.

3.2 Vérifier le jeton JWT

Lorsque le client envoie une demande, le jeton JWT doit être stocké localement et envoyé au serveur en tant qu'en-tête d'autorisation dans chaque demande. Après avoir reçu la demande, le serveur doit vérifier la validité du jeton JWT.

Le jeton JWT peut être vérifié à l'aide du code suivant :

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")
}

Dans le code ci-dessus, nous définissons le secret sur "secret", utilisons la méthode jwt.Parse pour analyser le jeton JWT et utilisons token.Claims.(jwt .MapClaims) Convertissez les informations de charge utile en type MapClaims. Enfin, nous vérifions que le token JWT est valide.

4. Conclusion

Utiliser JWT pour implémenter l'authentification OAuth2.0 dans les projets Golang est très simple, il vous suffit de suivre les deux étapes ci-dessus. En tant que méthode d'authentification standard, JWT offre d'excellentes performances et sécurité entre domaines. Il peut nous fournir une méthode d'authentification efficace, sûre et pratique, ce qui améliore considérablement l'efficacité du développement et l'expérience utilisateur.

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!