Golang Learning Authentification et autorisation du serveur Web

Golang est un langage émergent, particulièrement adapté à la mise en œuvre de services Web. Dans les services Web, l'authentification et l'autorisation sont des mécanismes de sécurité très importants. Cet article expliquera comment implémenter l'authentification et l'autorisation du serveur Web dans Golang.

L'authentification (Authentification) fait référence à la vérification de l'identité de l'utilisateur et à la détermination s'il a le droit d'accéder aux ressources. Les méthodes d'authentification courantes incluent le nom d'utilisateur et le mot de passe, le jeton, etc. L'autorisation fait référence à la détermination si un utilisateur a l'autorisation d'accéder à une ressource. Inclut généralement des méthodes de contrôle d’accès basées sur les rôles et d’autorisation de contrôle d’accès basées sur les ressources.

Une variété de frameworks et de bibliothèques peuvent être utilisées dans Golang pour implémenter l'authentification et l'autorisation des services Web. Cet article prend le framework Gin comme exemple pour présenter comment implémenter l'authentification basée sur les jetons et l'autorisation basée sur les rôles.

1. Authentification basée sur des jetons

Dans le framework Gin, JWT (Json Web Token) peut être utilisé pour implémenter une authentification basée sur des jetons. JWT est un standard ouvert qui définit un moyen concis et autonome de transmettre en toute sécurité des informations sur le Web. JWT se compose de trois parties : en-tête, charge utile et signature.

L'en-tête est utilisé pour décrire le type de jeton et l'algorithme de signature, par exemple :

{"alg": "HS256", "typ": "JWT"}

La charge utile est utilisée pour stocker les informations qui doit être transmis, comme le nom d'utilisateur, les rôles, etc., par exemple :

{"sub": "123456789", "name": "John Doe", "iat": 1516239022}

La signature est utilisée pour empêcher la falsification des informations et une clé privée est requise pour la signature :

HMACSHA256(
base64UrlEncode(header) + "." +
base64UrlEncode(payload),
secret)

Dans Golang, vous pouvez utiliser la bibliothèque github.com/dgrijalva/jwt-go pour réaliser la génération et la vérification JWT. Par exemple :

// Créez un nouvel objet token, en spécifiant la méthode de signature et les revendications que vous souhaitez qu'il contienne.
token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{

"sub": "1234567890",
"name": "John Doe",
"iat": 1516239022,

})

/ / Signez et obtenez le jeton encodé complet sous forme de chaîne en utilisant le secret
tokenString, err := token.SignedString([]byte("secret"))

// Analysez le jeton pour vérifier sa validité et extrayez les réclamations
jeton , err := jwt.ParseWithClaims(tokenString, &MyCustomClaims{}, func(token *jwt.Token) (interface{}, error) {

return []byte("secret"), nil

})

Dans le framework Gin, vous pouvez utiliser la bibliothèque gin-jwt pour créer rapidement un mécanisme d'authentification basé sur JWT. Par exemple :

// Créez un nouveau middleware JWT avec la clé de signature spécifiée
middleware := jwtmiddleware.New(jwtmiddleware.Options{

SigningMethod:   jwt.SigningMethodHS256,
Claims:          &CustomClaims{},
KeyFunc: func(token *jwt.Token) (interface{}, error) {
    // Check the signing method and return the key for verifying the signature
    if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
        return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
    }
    return []byte("secret"), nil
},

})

// Utilisez le middleware dans une route Gin pour protéger la ressource
router .GET("/protected", middleware.MiddlewareFunc(), func(c *gin.Context) {

claims := jwtmiddleware.ExtractClaims(c)
user := claims["user"].(string)
c.JSON(200, gin.H{
    "user": user,
    "message": "Hello, World!",
})

})

2 Autorisation basée sur les rôles

Dans le framework Gin, vous pouvez utiliser l'autorisation basée sur les rôles. autorisation de limiter l'accès des utilisateurs aux ressources. Par exemple, dans une application de blog, les rôles sont utilisés pour distinguer les utilisateurs ordinaires et les administrateurs. Les administrateurs peuvent accéder à toutes les ressources du blog, tandis que les utilisateurs ordinaires ne peuvent accéder qu'aux ressources du blog publiées par eux-mêmes.

Vous pouvez utiliser la bibliothèque gin-authz pour implémenter une autorisation basée sur les rôles. Par exemple :

// Définir le middleware d'autorisation pour appliquer l'accès basé sur les rôles
authMiddleware := authz.NewAuthorizer(authz.BuiltinRolebased())

// Définir une politique basée sur les rôles pour accorder l'accès au rôle "admin" à toutes les ressources
adminRole := authz.NewRole("admin", []string{"*"})
policy := authz.NewPolicy()
policy.AddRole(adminRole)

// Utilisez le middleware de stratégie dans un Route Gin pour appliquer le contrôle d'accès basé sur les rôles
router.GET("/blogs", authMiddleware.CheckPermission(policy, "admin"), func(c *gin.Context) {

// Return the list of all blogs

})

router.GET ( "/blog/:id", authMiddleware.CheckPermission(policy, "read"), func(c *gin.Context) {

// Return the specified blog

})

router.POST("/blog", authMiddleware.CheckPermission(policy , "write"), func(c *gin.Context) {

// Create a new blog

})

Dans le code ci-dessus, un rôle nommé "admin" est défini, qui a accès à toutes les ressources ("*"). Ensuite, dans chaque itinéraire, vérifiez si le rôle de l'utilisateur a accès à la ressource à l'aide de la fonction authMiddleware.CheckPermission.

Résumé

Cet article présente comment implémenter l'authentification et l'autorisation du serveur Web dans Golang. En utilisant le framework Gin et les bibliothèques associées, nous pouvons rapidement créer des services Web sécurisés et fiables.

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!