Comment implémenter l'authentification et l'autorisation à l'aide de Golang

Avec le développement continu des applications Internet, l'authentification et l'autorisation des utilisateurs deviennent de plus en plus importantes. L'authentification est le processus permettant de vérifier qu'un utilisateur est autorisé à accéder à un système, tandis que l'autorisation est le processus permettant de déterminer les actions qu'un utilisateur peut effectuer. Dans cet article, nous verrons comment implémenter l'authentification et l'autorisation à l'aide de Golang.

1. L'authentification à l'aide de JWT

JWT (JSON Web Tokens) est un moyen compact et autonome de représenter l'identité d'un utilisateur. Il contient des métadonnées et des affirmations qui peuvent être vérifiées et décodées. De manière générale, JWT contient trois parties : l'en-tête, la charge utile et la signature.

Golang fournit de nombreuses bibliothèques utiles pour nous aider à implémenter JWT, telles que : jwt-go. Générer, décoder et valider des JWT est facile grâce à la bibliothèque jwt-go. Voici un exemple de code qui utilise la bibliothèque jwt-go pour générer un JWT :

import (
    "time"
    "github.com/dgrijalva/jwt-go"
)
  
func CreateToken(userId string) (string, error) {
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
        "user_id": userId,
        "exp":     time.Now().Add(time.Hour * 24).Unix(),
    })
  
    return token.SignedString([]byte("your-secret"))
}

Dans le code ci-dessus, nous créons un JWT qui contient l'ID de l'utilisateur actuel et l'heure d'expiration. Signez ensuite le JWT à l'aide de la méthode jwt.SigningMethodHS256 et de la clé « your-secret ». Enfin, la chaîne JWT est renvoyée à l'appelant.

Pour chaque requête HTTP, nous pouvons utiliser JWT pour l'authentification. Une fois que l'utilisateur s'est connecté avec succès, nous pouvons renvoyer le JWT généré au client. Le client peut envoyer le JWT au serveur dans le cadre de l'en-tête « Autorisation » à chaque demande ultérieure. Le serveur décode le JWT et vérifie la signature pour s'assurer qu'elle est légitime. Voici un exemple de code pour valider JWT à l'aide de la bibliothèque jwt-go :

import (
    "net/http"
    "github.com/dgrijalva/jwt-go"
)
  
func ValidateTokenMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        tokenHeader := r.Header.Get("Authorization")
        if tokenHeader == "" {
            w.WriteHeader(http.StatusUnauthorized)
            return
        }
  
        token, err := jwt.Parse(tokenHeader, func(token *jwt.Token) (interface{}, error) {
            return []byte("your-secret"), nil
        })
  
        if err != nil || !token.Valid {
            w.WriteHeader(http.StatusUnauthorized)
            return
        }
  
        next.ServeHTTP(w, r)
    })
}

Dans le code ci-dessus, nous avons défini un middleware appelé ValidateTokenMiddleware, qui est responsable de la validation de JWT. ValidateTokenMiddleware vérifiera si l'en-tête HTTP contient un jeton d'autorisation et le validera. Si le JWT n'est pas valide, il renvoie une réponse HTTP 401 non autorisée. Dans le cas contraire, il poursuivra le traitement de la demande.

L'utilisation de JWT pour l'authentification garantit que la demande provient d'un utilisateur légitime et offre une sécurité accrue.

2. Utiliser des rôles pour l'autorisation

Dans les applications Web modernes, les utilisateurs doivent souvent avoir des rôles et des autorisations différents. Par exemple, un administrateur peut disposer d'autorisations lui permettant d'effectuer des opérations de niveau supérieur, ce que les utilisateurs ordinaires ne disposent pas. Par conséquent, nous devons autoriser différents rôles d’utilisateur séparément.

Dans Golang, une approche populaire consiste à utiliser le modèle de contrôle d'accès basé sur les rôles (RBAC). Dans le modèle RBAC, chaque rôle reçoit des autorisations différentes et les utilisateurs se voient attribuer un ou plusieurs rôles. Ensuite, avant d'effectuer une action spécifique, le système vérifie si l'utilisateur est autorisé à effectuer cette action.

Voici un exemple de code utilisant le modèle de contrôle d'accès basé sur les rôles :

type Role string
  
const (
    AdminRole  Role = "admin"
    UserRole   Role = "user"
)
  
type User struct {
    ID    string `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email"`
    Role  Role   `json:"role"`
}
  
// Check if the user has permission to access the resource based on the specified role.
func HasPermission(user *User, requiredRole Role) bool {
    return user.Role == requiredRole || user.Role == AdminRole
}

Dans le code ci-dessus, nous avons défini un type d'énumération appelé Rôle qui contient une liste de rôles que nous souhaitons utiliser dans notre application. Dans la structure Utilisateur, nous attribuons à chaque utilisateur un ou plusieurs rôles et utilisons la fonction HasPermission pour vérifier si l'utilisateur est autorisé à effectuer une opération spécifique. Dans cet exemple, la fonction HasPermission renverra true uniquement si le rôle de l'utilisateur est AdminRole ou requisRole.

Nous pouvons également utiliser d'autres méthodes telles que l'utilisation d'un middleware pour vérifier les rôles et les autorisations des utilisateurs. Voici un exemple de code basé sur un middleware :

func AdminOnlyMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        user, ok := r.Context().Value("user").(*User)
        if !ok || !HasPermission(user, AdminRole) {
            w.WriteHeader(http.StatusForbidden)
            return
        }
  
        next.ServeHTTP(w, r)
    })
}

Dans le code ci-dessus, nous définissons un middleware appelé AdminOnlyMiddleware. Ce middleware obtiendra le rôle d'utilisateur à partir du contexte de la requête HTTP et vérifiera si l'utilisateur dispose des autorisations nécessaires pour effectuer l'action. Si l'utilisateur n'a pas l'autorisation, il renverra une réponse HTTP 403 Forbidden.

Si nous utilisons une application basée sur un framework Web, nous pouvons enregistrer le middleware directement sur l'itinéraire. Par exemple, nous pouvons enregistrer AdminOnlyMiddleware pour les points de terminaison d'API qui nécessitent des droits d'administrateur :

router.Handle("/api/dashboard", AdminOnlyMiddleware(http.HandlerFunc(handler)))

Dans le code ci-dessus, seuls les utilisateurs disposant de droits d'administrateur peuvent accéder au point de terminaison "/api/dashboard".

Résumé

Dans cet article, nous avons présenté comment mettre en œuvre l'authentification et l'autorisation à l'aide de Golang. Nous utilisons JWT pour vérifier que l'utilisateur a l'autorisation d'accéder au système et un modèle de contrôle d'accès basé sur les rôles pour vérifier si l'utilisateur a l'autorisation d'effectuer une action spécifique. Ces technologies peuvent nous aider à créer des applications Web sécurisées, évolutives et faciles à maintenir.

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!