Autorisation et authentification en Go (Golang) : guide complet

Autorisation et authentification en Go (Golang)

Dans le développement web moderne avec Go (Golang), la sécurité des données utilisateur et le contrôle d'accès sont des aspects critiques. Les bibliothèques et outils d'autorisation et d'authentification permettent aux développeurs d'implémenter rapidement et de manière fiable la protection dans leurs applications. Dans cet article, nous examinerons les approches principales et les bibliothèques populaires pour implémenter l'authentification (vérification de l'identité de l'utilisateur) et l'autorisation (détermination des droits d'accès) en Go.

Concepts fondamentaux

Avant de passer aux outils, il est important de distinguer deux notions clés :

• Authentification — processus de vérification que l'utilisateur est bien celui qu'il prétend être (généralement via identifiant/mot de passe, jetons, OAuth).
• Autorisation — processus de détermination des ressources et actions accessibles à un utilisateur authentifié (rôles, droits d'accès).

Bibliothèques et outils populaires

1. bcrypt pour le hachage des mots de passe

La bibliothèque golang.org/x/crypto/bcrypt est la norme de facto pour le stockage sécurisé des mots de passe. Elle ajoute automatiquement un sel et utilise une fonction de hachage adaptative.

package main

import (    "fmt"    "golang.org/x/crypto/bcrypt")

func main() {    password := "mySecretPassword123"        // Hachage du mot de passe    hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)    if err != nil {        panic(err)    }    fmt.Printf("Hash: %s", hash)        // Vérification du mot de passe    err = bcrypt.CompareHashAndPassword(hash, []byte("wrongPassword"))    if err != nil {        fmt.Println("Mot de passe incorrect :", err)    } else {        fmt.Println("Mot de passe correct")    }        // Vérification réussie    err = bcrypt.CompareHashAndPassword(hash, []byte(password))    if err == nil {        fmt.Println("Mot de passe correct !")    }}

2. JWT (JSON Web Tokens) avec la bibliothèque golang-jwt

La bibliothèque github.com/golang-jwt/jwt/v5 permet de créer et vérifier des jetons JWT. C'est une méthode populaire pour implémenter l'authentification sans état (stateless).

package main

import (    "fmt"    "time"    "github.com/golang-jwt/jwt/v5")

var jwtSecret = []byte("super-secret-key")

func createToken(userID string) (string, error) {    claims := jwt.MapClaims{        "user_id": userID,        "exp":     time.Now().Add(time.Hour * 24).Unix(),        "iat":     time.Now().Unix(),    }        token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)    return token.SignedString(jwtSecret)}

func validateToken(tokenString string) (string, error) {    token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {        if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {            return nil, fmt.Errorf("méthode de signature inattendue : %v", token.Header["alg"])        }        return jwtSecret, nil    })        if err != nil {        return "", err    }        if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {        return claims["user_id"].(string), nil    }        return "", fmt.Errorf("jeton invalide")}

func main() {    // Création du jeton    token, _ := createToken("user123")    fmt.Println("Jeton JWT :", token)        // Vérification du jeton    userID, err := validateToken(token)    if err != nil {        fmt.Println("Erreur de validation :", err)    } else {        fmt.Println("ID utilisateur du jeton :", userID)    }}

3. Authentification basée sur les sessions avec gorilla/sessions

Pour l'authentification traditionnelle par session, utilisez github.com/gorilla/sessions. Les sessions sont stockées sur le serveur, et seul un cookie contenant l'ID de session est transmis au client.

package main

import (    "net/http"    "github.com/gorilla/sessions")\