Middleware d'authentification de base pour Iris

Aperçu

Le middleware d'authentification de base offre un moyen robuste et flexible de sécuriser vos applications Web Iris. Il prend en charge diverses méthodes de stockage utilisateur, notamment les listes, fichiers et bases de données en mémoire, et offre des fonctionnalités avancées telles que le cryptage des mots de passe, la gestion personnalisée des erreurs et l'expiration de la session.

Installation

Pour utiliser le middleware basicauth, vous devez l'importer dans votre application Iris :

import "github.com/kataras/iris/v12/middleware/basicauth"

Caractéristiques

Fonction d'authentification

Le cœur du middleware est le champ Autoriser, qui est une fonction avec la signature suivante :

func(ctx iris.Context, username, password string) (any, bool)

Cette fonction se charge de valider le nom d'utilisateur et le mot de passe. Il renvoie un objet utilisateur (ou tout autre type) et un booléen indiquant si l'authentification a réussi.

Structure utilisateur (assistant)

Bien que le middleware ne nécessite pas de structure utilisateur spécifique, vous pouvez utiliser une structure d'assistance pour gérer les données utilisateur plus facilement. Voici un exemple de structure d'utilisateurs :

type User struct {
    Username string   `json:"username"`
    Password string   `json:"password"`
    Roles    []string `json:"roles"`
}

Stockage utilisateur en mémoire

Vous pouvez stocker les utilisateurs en mémoire à l'aide d'une tranche de structures utilisateur. Ceci est utile pour les petites applications ou à des fins de test.

var users = []User{
    {"admin", "admin", []string{"admin"}},
    {"kataras", "kataras_pass", []string{"manager", "author"}},
    {"george", "george_pass", []string{"member"}},
    {"john", "john_pass", []string{}},
}

Configuration de base

Pour configurer le middleware, créez une instance de basicauth.Options et transmettez-la à basicauth.New.

opts := basicauth.Options{
    Realm: basicauth.DefaultRealm,
    MaxAge: 10 * time.Minute,
    GC: basicauth.GC{
        Every: 2 * time.Hour,
    },
    Allow: basicauth.AllowUsers(users),
}

auth := basicauth.New(opts)

Utilisation d'un fichier pour le stockage utilisateur

Vous pouvez charger des utilisateurs à partir d'un fichier (JSON ou YAML). Ceci est utile pour les applications où les données utilisateur changent fréquemment.

auth := basicauth.Load("users.yml")

Option BCRYPT

L'option BCRYPT vous permet d'utiliser bcrypt pour le hachage de mot de passe. Bcrypt est une fonction de hachage de mot de passe conçue pour nécessiter beaucoup de calculs afin de résister aux attaques par force brute. Il est largement utilisé pour stocker en toute sécurité les mots de passe.

auth := basicauth.Load("users.yml", basicauth.BCRYPT)

Vous pouvez également utiliser l'option BCRYPT avec d'autres méthodes de récupération d'utilisateurs, telles que le stockage en mémoire ou dans une base de données.

Utilisation d'une base de données pour le stockage des utilisateurs

Pour une gestion plus dynamique des utilisateurs, vous pouvez valider les utilisateurs par rapport à une base de données. Voici un exemple de configuration du middleware à l'aide d'une base de données MySQL :

package main

import (
    "context"
    "database/sql"
    "fmt"
    "os"

    "github.com/kataras/iris/v12"
    "github.com/kataras/iris/v12/middleware/basicauth"

    _ "github.com/go-sql-driver/mysql"
)

type User struct {
    ID       int64  `db:"id" json:"id"`
    Username string `db:"username" json:"username"`
    Password string `db:"password" json:"password"`
    Email    string `db:"email" json:"email"`
}

func (u User) GetUsername() string {
    return u.Username
}

func (u User) GetPassword() string {
    return u.Password
}

func main() {
    dsn := fmt.Sprintf("%s:%s@tcp(%s:3306)/%s?parseTime=true&charset=utf8mb4&collation=utf8mb4_unicode_ci",
        getenv("MYSQL_USER", "user_myapp"),
        getenv("MYSQL_PASSWORD", "dbpassword"),


    get

env("MYSQL_HOST", "localhost"),
        getenv("MYSQL_DATABASE", "myapp"),
    )
    db, err := connect(dsn)
    if err != nil {
        panic(err)
    }

    // Validate a user from database.
    allowFunc := func(ctx iris.Context, username, password string) (any, bool) {
        user, err := db.getUserByUsernameAndPassword(context.Background(), username, password)
        return user, err == nil
    }

    opts := basicauth.Options{
        Realm:        basicauth.DefaultRealm,
        ErrorHandler: basicauth.DefaultErrorHandler,
        Allow:        allowFunc,
    }

    auth := basicauth.New(opts)

    app := iris.New()
    app.Use(auth)
    app.Get("/", index)
    app.Listen(":8080")
}

func index(ctx iris.Context) {
    user, _ := ctx.User().GetRaw()
    // user is a type of main.User
    ctx.JSON(user)
}

Gestion des erreurs personnalisée

Vous pouvez personnaliser le comportement de gestion des erreurs en définissant le champ ErrorHandler dans basicauth.Options.

opts := basicauth.Options{
    ErrorHandler: func(ctx iris.Context, err error) {
        ctx.StatusCode(iris.StatusUnauthorized)
        ctx.JSON(iris.Map{"error": "Unauthorized"})
    },
}

Expiration de la session

Le middleware prend en charge l'expiration de la session. Vous pouvez définir le champ MaxAge pour spécifier la durée après laquelle l'utilisateur doit se réauthentifier.

opts := basicauth.Options{
    MaxAge: 10 * time.Minute,
}

Collecte des déchets

Pour effacer les utilisateurs expirés de la mémoire, vous pouvez définir le champ GC.

import "github.com/kataras/iris/v12/middleware/basicauth"

Test des gestionnaires avec le middleware BasicAuth

Pour tester les gestionnaires qui utilisent le middleware BasicAuth, vous pouvez utiliser le

httptest

forfait fourni par Iris. Voici un exemple de comment tester un gestionnaire :

func(ctx iris.Context, username, password string) (any, bool)

Exemple

Voici un exemple complet qui montre comment configurer le middleware avec le stockage utilisateur en mémoire :

type User struct {
    Username string   `json:"username"`
    Password string   `json:"password"`
    Roles    []string `json:"roles"`
}

Conclusion

Le middleware d'authentification de base fournit une solution complète pour sécuriser vos applications Web Iris. Avec la prise en charge de diverses méthodes de stockage utilisateur, des fonctionnalités avancées telles que le cryptage des mots de passe et la gestion personnalisée des erreurs, ainsi qu'une intégration facile, il s'agit d'un outil puissant pour les développeurs.

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!