Jetons JWT dans Golang : guide du développeur pour les API sécurisées

Présentation

Dans le développement Web moderne, une authentification sécurisée et évolutive est cruciale. Les jetons Web JSON (JWT) sont devenus le moyen standard d'atteindre cet objectif. Dans cet article de blog, nous explorerons ce qu'est JWT, comment il fonctionne et comment l'implémenter dans Golang.

Qu'est-ce que JWT ?

JSON Web Token (JWT) est un moyen compact et sécurisé pour les URL de représenter les revendications afin de transmettre en toute sécurité les revendications entre deux parties. Il est couramment utilisé pour authentifier et autoriser les utilisateurs dans les API et les systèmes distribués.

Structure de JWT

Un JWT se compose de trois parties séparées par des points (.) :

<code>Header.Payload.Signature</code>

Exemple :

<code>eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWUsImlhdCI6MTUxNjIzOTAyMn0.reGQzG3OKdoIMWLDKOZ4TICJit3EW69cQE72E2CfzRE</code>

Chaque partie est :

1. En-tête : Spécifie le type de jeton (JWT) et l'algorithme de signature (HS256).

<code>{
  "alg": "HS256",
  "typ": "JWT"
}</code>

2. Charge utile : Contient des revendications (données utilisateur telles que l'identifiant, le rôle ou le nom).

<code>{
    "sub": "1234567890",
    "name": "John Doe",
    "admin": true,
    "iat": 1516239022
}</code>

3. Signature : Utilise un processus de signature cryptographique pour garantir l'intégrité du jeton. Explorons cela en détail.

Comment créer une signature :

• Connectez l'en-tête et la charge utile codés :

<code>  base64UrlEncode(header) + "." + base64UrlEncode(payload)</code>

• Signez le résultat :
  • Utilisez un algorithme de signature cryptographique (par exemple, HMACSHA256, RS256) à l'aide d'une clé secrète ou d'une clé privée.
• Signature supplémentaire : Le JWT final devient

<code>  header.payload.signature</code>

Comment fonctionne JWT

1. Le client envoie les informations de connexion au serveur.
2. S'il est valide, le serveur générera le JWT et le renverra au client.
3. Le client stocke JWT (par exemple dans localStorage ou cookie).
4. Pour chaque demande, le client inclut le JWT dans l'en-tête Autorisation : Autorisation : Porteur
5. Le serveur valide le JWT à chaque requête.
   • Recalculez la signature en utilisant l'en-tête et la charge utile reçus.
   • Comparez la signature recalculée avec la signature reçue.

Implémentation de JWT dans Golang

Les développeurs Golang peuvent tirer parti de l'excellente bibliothèque golang-jwt/jwt pour gérer JWT. Cette bibliothèque fournit des fonctionnalités puissantes pour créer, signer et valider des JWT. Vous pouvez le trouver ici.

Cependant, la gestion des JWT nécessite souvent des tâches répétitives telles que la configuration des méthodes de signature, l'analyse des jetons et la validation des revendications. Pour simplifier cela, j'ai écrit un package personnalisé pour envelopper les fonctionnalités de golang-jwt. Vous pouvez consulter mon colis ici. Voici un exemple d'utilisation de mon package JWT personnalisé.

<code class="language-go">package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "github.com/golang-jwt/jwt/v5"
    jwtutil "github.com/kittipat1413/go-common/util/jwt"
)

type MyCustomClaims struct {
    jwt.RegisteredClaims
    UserID string `json:"uid"`
}

func main() {
    ctx := context.Background()
    signingKey := []byte("super-secret-key")
    manager, err := jwtutil.NewJWTManager(jwtutil.HS256, signingKey)
    if err != nil {
        log.Fatalf("Failed to create JWTManager: %v", err)
    }

    // Prepare custom claims
    claims := &MyCustomClaims{
        RegisteredClaims: jwt.RegisteredClaims{
            ExpiresAt: jwt.NewNumericDate(time.Now().Add(15 * time.Minute)),
            Issuer:    "example-HS256",
            Subject:   "example-subject",
        },
        UserID: "abc123",
    }

    // Create the token
    tokenStringHS256, err := manager.CreateToken(ctx, claims)
    if err != nil {
        log.Fatalf("Failed to create token: %v", err)
    }
    fmt.Println("Generated Token:", tokenStringHS256)

    // Validate the token
    parsedClaims := &MyCustomClaims{}
    err = manager.ParseAndValidateToken(ctx, tokenStringHS256, parsedClaims)
    if err != nil {
        log.Fatalf("Failed to validate token: %v", err)
    }

    fmt.Printf("Token is valid! UserID: %s, Issuer: %s\n", parsedClaims.UserID, parsedClaims.Issuer)
}</code>

Vous pouvez parcourir l'implémentation complète et la documentation de mon package sur GitHub : ici.

Bonnes pratiques JWT

1. Utilisez HTTPS : Transférez toujours les jetons via un canal sécurisé.
2. Définissez le délai d'expiration : Incluez une exp raisonnable pour limiter l'abus de jetons.
3. Protégez vos clés : Stockez vos clés en toute sécurité à l'aide de variables d'environnement ou d'un gestionnaire de clés.
4. Évitez d'utiliser des données sensibles dans la charge utile : Incluez uniquement les informations non critiques.
5. Utiliser un jeton d'actualisation : Associez un JWT à un jeton d'actualisation pour prolonger la session en toute sécurité.

Conclusion ?

JWT est un outil puissant pour une authentification sécurisée et sans état. La signature garantit l'intégrité et l'authenticité du jeton, ce qui rend JWT idéal pour les API et les systèmes distribués. En utilisant des bibliothèques comme jwt-go, vous pouvez facilement implémenter JWT dans votre projet Golang.

☕ Soutenez mon travail ☕

Si vous aimez mon travail, pensez à m'offrir un café ! Votre soutien m'aide à continuer à créer du contenu précieux et à partager des connaissances. ☕

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!