Comment implémenter sso dans Golang

À l'ère d'Internet d'aujourd'hui, l'authentification unique (SSO) est devenue l'une des technologies les plus importantes. Cela facilite non seulement la connexion des utilisateurs, mais améliore également la sécurité du site Web. Ces dernières années, en raison de son efficacité et de sa stabilité, Golang est progressivement devenu le langage de développement choisi par de nombreuses entreprises et a attiré de plus en plus l'attention des développeurs en train de mettre en œuvre le SSO. Nous présenterons ensuite comment Golang implémente le SSO.

1. Qu'est-ce que SSO

SSO, le nom complet est Single Sign On, fait référence à une technologie qui permet à plusieurs applications de partager le même système d'authentification. Sa fonction principale est de permettre aux utilisateurs de se connecter une seule fois à plusieurs systèmes différents pour fonctionner dans ces systèmes. Cela peut non seulement réduire les opérations des utilisateurs et améliorer l'efficacité du travail, mais également éviter le problème des utilisateurs qui oublient les mots de passe de leur compte. La méthode de mise en œuvre de SSO la plus couramment utilisée est basée sur le mécanisme d'authentification par jeton. Une fois que l'utilisateur s'est connecté avec succès, le serveur renvoie un jeton au client. En même temps, le jeton est utilisé comme identifiant unique de l'identité de l'utilisateur. Lorsque l'utilisateur accède à d'autres systèmes, il lui suffit de porter le Token Can.

2. Le processus de mise en œuvre de l'authentification unique dans Golang

1. Authentification de connexion

Tout d'abord, lorsqu'un utilisateur accède à un système, il doit d'abord effectuer une authentification de connexion, et le système doit vérifier si le nom d'utilisateur et le mot de passe sont correct. Si c'est correct, un jeton est généré et renvoyé au client. Ce token peut être utilisé pendant une certaine période. S'il expire, vous devez vous reconnecter. Dans Golang, vous pouvez utiliser JWT (JSON Web Tokens) pour générer des jetons. JWT est un standard ouvert et peut être utilisé pour une vérification sécurisée et un transfert de données dans une variété de scénarios. Parmi eux, JWT se compose de trois parties : en-tête, charge utile et signature. Toutes les informations peuvent être stockées dans l'en-tête et la charge utile, telles que l'ID utilisateur, etc., qui peuvent être utilisées à des fins de jugement lors d'une vérification ultérieure. La signature est une signature générée sur la base du cryptage de l'en-tête et de la charge utile pour garantir la sécurité du jeton.

2. Vérification du jeton

Pendant le processus d'authentification SSO, le système doit vérifier le jeton pour s'assurer que le jeton est généré par le système et qu'il est dans la période de validité. Le processus de vérification peut être effectué dans chaque système ou via un système d'authentification dédié. Dans Golang, la vérification des jetons peut être effectuée via un middleware. Nous pouvons définir un middleware pour vérifier si le jeton dans l'en-tête de la requête répond aux exigences. Si ce n'est pas le cas, il renverra un message d'erreur. Si c'est le cas, il passera à l'étape suivante.

func AuthMiddleware(suivant http.Handler) http.Handler {

return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 
    authHeader := r.Header.Get("Authorization") 
    if authHeader == "" { 
        http.Error(w, "Authorization required", http.StatusUnauthorized) 
        return 
    } 
    token, err := jwt.Parse(authHeader, 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 []byte("secret"),nil //这里是Token的密钥，可以根据实际需要进行设置 
    }) 
    if err != nil || !token.Valid { 
        http.Error(w, "Invalid token", http.StatusUnauthorized) 
        return 
    } 
    // Token校验通过 
    next.ServeHTTP(w, r) 
})

}

3. Actualisation du jeton

L'expiration et l'actualisation du jeton sont un autre élément très important dans l'authentification SSO. Si le jeton expire, l'authentification de connexion doit être saisie à nouveau et les utilisateurs basculent souvent entre différents systèmes. S'ils doivent se reconnecter à chaque fois, cela sera non seulement fastidieux, mais aura également un impact négatif sur l'expérience utilisateur. . Par conséquent, lorsque le jeton est sur le point d'expirer, nous pouvons actualiser le jeton via une interface spéciale pour garder l'utilisateur connecté. Dans Golang, vous pouvez définir un délai d'expiration du jeton lorsque le jeton est sur le point d'expirer, actualisez-le via Actualiser le jeton, évitant ainsi aux utilisateurs d'avoir à se réauthentifier.

func RefreshToken(w http.ResponseWriter, r *http.Request) {

authHeader := r.Header.Get("Authorization") 
if authHeader == "" { 
    http.Error(w, "Authorization required", http.StatusUnauthorized) 
    return 
} 
token, err := jwt.Parse(authHeader, 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 []byte("secret"),nil //这里是Token的密钥，可以根据实际需要进行设置 
}) 
if err != nil { 
    http.Error(w, "Invalid token", http.StatusUnauthorized) 
    return 
} 
if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid { 
    if time.Unix(int64(claims["exp"].(float64)), 0).Sub(time.Now())/time.Second < RefreshTokenExpired { 
        newToken := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{ 
            "user_id": claims["user_id"], 
            "exp": time.Now().Add(time.Hour * 24).Unix(), 
        }) 
        tokenString, _ := newToken.SignedString([]byte("secret")) 
        w.WriteHeader(http.StatusOK) 
        w.Write([]byte(tokenString)) 
        return 
    } 
} 
http.Error(w, "Failed to refresh token", http.StatusUnauthorized)

}

4. Traitement inter-domaines

Lors de l'authentification SSO, étant donné que le jeton et d'autres informations doivent être transférés entre chaque système, Cross -les problèmes de domaine doivent être pris en compte. Dans Golang, les problèmes inter-domaines peuvent être résolus en modifiant l'en-tête. Nous pouvons définir un middleware inter-domaines et ajouter l'en-tête correspondant à la requête pour résoudre le problème des requêtes inter-domaines.

func CORSMiddleware(suivant http.Handler) http.Handler {

return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 
    w.Header().Set("Access-Control-Allow-Origin", "*") 
    w.Header().Set("Access-Control-Allow-Methods", "GET, POST, DELETE, PUT, OPTIONS") 
    w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization") 
    if r.Method == "OPTIONS" { 
        w.WriteHeader(http.StatusOK) 
        return 
    } 
    next.ServeHTTP(w, r) 
})

}

3. Résumé

À l'ère d'Internet d'aujourd'hui, le SSO est devenu l'une des technologies les plus importantes. Ces dernières années, Golang est progressivement devenu le langage de développement choisi par de nombreuses entreprises et a attiré de plus en plus l'attention des développeurs en train de mettre en œuvre le SSO. Grâce à l'introduction ci-dessus, nous pouvons voir qu'il n'est pas difficile d'implémenter le SSO dans Golang. Nous pouvons générer un jeton via JWT et effectuer une vérification du jeton et un traitement inter-domaines via un middleware pour réaliser la fonction SSO.

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!