Autorisation et authentification en Go (Golang)

Autorisation et authentification en Go (Golang) : aperçu des outils clés

L'authentification (vérification de l'identité de l'utilisateur) et l'autorisation (vérification des droits d'accès) sont des composants fondamentaux de toute application web. Dans l'écosystème Go (Golang), il existe plusieurs bibliothèques éprouvées qui permettent de mettre en œuvre ces mécanismes rapidement, en toute sécurité et avec un minimum de code. Dans cet article, nous examinerons quatre approches principales : le hachage de mots de passe, les jetons JWT, la gestion des sessions et OAuth2.

1. Hachage de mots de passe : `golang.org/x/crypto/bcrypt`

La première étape de toute authentification est le stockage sécurisé des mots de passe. Ne stockez jamais les mots de passe en clair ! Le package bcrypt de la collection standard de Go fournit un algorithme de hachage éprouvé avec un coût adaptatif (cost factor).

Installation :

go get golang.org/x/crypto/bcrypt

Exemple d'inscription et de connexion :

package main

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

func hashPassword(password string) (string, error) {    bytes, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)    return string(bytes), err}

func checkPasswordHash(password, hash string) bool {    err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password))    return err == nil}

func main() {    password := "mySecretP@ssw0rd"    hash, _ := hashPassword(password)

    fmt.Println("Hash:", hash)

    // Vérification du mot de passe correct    match := checkPasswordHash(password, hash)    fmt.Println("Password match:", match) // true

    // Vérification d'un mot de passe incorrect    match = checkPasswordHash("wrong", hash)    fmt.Println("Wrong password match:", match) // false}

Important : bcrypt.DefaultCost est égal à 10. Pour un niveau de sécurité plus élevé (mais plus lent), utilisez une valeur de 12 à 14. N'utilisez jamais un coût inférieur à 10.

2. JWT (JSON Web Tokens) — `github.com/golang-jwt/jwt/v5`

JWT est un moyen compact de transférer des données entre les parties sous la forme d'un objet JSON. Idéal pour les API REST et les microservices. Le package golang-jwt/jwt est le plus populaire et activement maintenu.

Installation :

go get github.com/golang-jwt/jwt/v5

Exemple de création et de vérification d'un JWT :

package main

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

var jwtSecret = []byte("your-secret-key-keep-it-safe")

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

func verifyToken(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("unexpected signing method: %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("invalid token")}

func main() {    token, _ := createToken("user123")    fmt.Println("JWT:", token)

    userID, err := verifyToken(token)    if err != nil {        fmt.Println("Error:", err)    } else {        fmt.Println("Authenticated user:", userID)    }}

Conseil : Stockez la clé secrète dans des variables d'environnement, pas dans le code. Pour la production, utilisez le chiffrement asymétrique (RS256).