Gopress, un blog en Golang (partie 8)
Bonjour à tous ! Nous continuons notre série sur la construction d'un blog avec Golang, le langage de programmation créé par Google qui devient de plus en plus populaire. Si vous avez manqué les parties précédentes, je vous invite à consulter nos articles précédents pour vous mettre à jour. Aujourd'hui, dans le huitième volet de notre série, nous allons nous concentrer sur l'authentification et la sécurité. Commençons !
Cases à cocher
Authentification et sécurité
Jusqu'à présent, nous avons créé notre blog, Gopress, avec des fonctionnalités de base, mais nous n'avons encore implémenté aucun mécanisme d'authentification. Nous ne voulons pas que n'importe qui puisse publier, modifier ou supprimer du contenu sur notre blog. Pour éviter cela, nous devons implémenter un système d'authentification.
En Golang, il existe plusieurs bibliothèques disponibles pour nous aider avec l'authentification, mais pour ce tutoriel, nous utiliserons "gorilla/sessions" pour gérer les sessions utilisateur et "golang.org/x/crypto/bcrypt" pour le hachage des mots de passe.
Implémentation des sessions avec Gorilla/Sessions
Pour commencer, nous devons installer le paquet Gorilla Sessions. Si vous utilisez go modules, vous pouvez le faire avec la commande suivante :
bashCopy codego get github.com/gorilla/sessions
D'abord, nous allons définir une variable globale pour notre stockage de sessions :
goCopy codevar (
key = []byte("super-secret-key")
store = sessions.NewCookieStore(key)
)
Une fois cela fait, nous pouvons implémenter une fonction pour établir une session après une connexion réussie :
goCopy codefunc setSession(userName string, w http.ResponseWriter, r *http.Request) {
session, _ := store.Get(r, "cookie-name")
session.Values["authenticated"] = true
session.Values["username"] = userName
session.Save(r, w)
}
Et une autre fonction pour vérifier si un utilisateur est authentifié :
goCopy codefunc checkSession(r *http.Request) bool {
session, _ := store.Get(r, "cookie-name")
if auth, ok := session.Values["authenticated"].(bool); !ok || !auth {
return false
}
return true
}
Hachage des mots de passe avec bcrypt
Maintenant, nous allons gérer les mots de passe de manière sécurisée avec bcrypt. Vous pouvez obtenir bcrypt avec la commande suivante :
bashCopy codego get golang.org/x/crypto/bcrypt
Lorsqu'un utilisateur s'inscrit ou change son mot de passe, nous devons nous assurer de ne pas stocker le mot de passe en texte clair. À la place, nous stockerons un hachage du mot de passe. Voici la fonction pour générer le hachage du mot de passe :
goCopy codefunc hashPassword(password string) (string, error) {
bytes, err := bcrypt.GenerateFromPassword([]byte(password), 14)
return string(bytes), err
}
Et lorsqu'un utilisateur se connecte, nous pouvons vérifier le mot de passe saisi avec le hachage stocké :
goCopy codefunc checkPasswordHash(password, hash string) bool {
err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password))
return err == nil
}
Et voilà pour aujourd'hui ! Vous avez maintenant les outils pour implémenter l'authentification dans votre blog Gopress. Dans le prochain article, nous nous concentrerons sur la gestion des rôles et des permissions pour les utilisateurs. Comme toujours, si vous avez des questions ou des problèmes, n'hésitez pas à nous laisser un commentaire.
Gestion des rôles et des permissions
Maintenant que nous avons l'authentification, nous pourrions vouloir implémenter des rôles et des permissions. Par exemple, nous pourrions vouloir un rôle d'« éditeur » qui peut réviser et approuver les publications avant qu'elles ne soient publiées, et un rôle d'« auteur » qui peut écrire et modifier ses propres publications, mais pas celles des autres.
Pour implémenter cela, nous devons d'abord étendre notre modèle d'utilisateur pour inclure un champ de rôle :
goCopy codetype User struct {
ID int
Username string
Password string
Role string
}
Ensuite, nous pouvons vérifier le rôle d'un utilisateur lors de l'authentification. Voici une fonction d'exemple qui vérifie si un utilisateur est un éditeur :
goCopy codefunc checkRole(r *http.Request) string {
session, _ := store.Get(r, "cookie-name")
role := session.Values["role"].(string)
return role
}
Nous pouvons utiliser cette fonction dans nos contrôleurs pour restreindre l'accès à certaines fonctions en fonction du rôle de l'utilisateur. Par exemple :
goCopy codefunc editPostHandler(w http.ResponseWriter, r *http.Request) {
if !checkSession(r) {
http.Redirect(w, r, "/login", 302)
return
}
if checkRole(r) != "editor" {
http.Error(w, "Forbidden", http.StatusForbidden)
return
}
// ... código para editar la publicación ...
}
Dans ce code, nous redirigeons les utilisateurs non authentifiés vers la page de connexion. Si l'utilisateur est authentifié mais n'est pas un éditeur, nous renvoyons une erreur 403 Forbidden. Seuls les éditeurs peuvent accéder à la fonctionnalité de modification des publications.
Nous espérons que cet article vous a été utile pour comprendre comment implémenter l'authentification et les rôles dans votre blog Gopress. Dans le prochain article, nous explorerons comment implémenter une fonctionnalité de recherche dans le blog. Rendez-vous dans le prochain épisode !
Comentarios