Comment authentifier l'identité dans Golang

Dans le monde Internet moderne, la sécurité et l'authentification de l'identité sont cruciales. Il en va de même pour les développeurs développant des applications utilisant Golang. Cet article expliquera l'authentification dans Golang, qui inclut l'authentification de base et l'authentification OAuth 2.0.

Authentification de base

L'authentification de base est l'une des méthodes d'authentification les plus simples et les plus courantes. Dans Golang, nous pouvons utiliser le package net/http intégré pour implémenter l'authentification de base. Voici un exemple : net/http包来实现基本身份验证。下面是一个示例：

package main

import (
    "fmt"
    "net/http"
)

func BasicAuth(handler http.HandlerFunc, username, password string) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        user, pass, ok := r.BasicAuth()
        if !ok || user != username || pass != password {
            w.Header().Set("WWW-Authenticate", `Basic realm="Restricted"`)
            w.WriteHeader(401)
            w.Write([]byte("Unauthorized.\n"))
            return
        }
        handler(w, r)
    }
}

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, World!")
}

func main() {
    username := "user"
    password := "pass"
    http.HandleFunc("/", BasicAuth(handler, username, password))
    http.ListenAndServe(":8080", nil)
}

在上面的示例中，我们定义了一个 BasicAuth 函数，用于验证用户名和密码是否与 r.BasicAuth() 提供的凭据相匹配。如果没有提供凭据或者提供的凭据不正确，则触发HTTP 401 Unauthorized 响应。如果凭据验证通过，则调用 handler 函数。

除了这个基本身份验证示例，还可以使用属于其他第三方的包提供的身份验证库，例如 Gorilla Toolkit。

OAuth 2.0认证

OAuth2.0是一种开放标准，用于允许第三方访问已授权用户的资源的流程。在Golang中，我们可以使用 go-oauth2/oauth2 包来实现OAuth 2.0认证。

第一步：注册应用程序并获取客户端ID和密钥

我们首先需要在 OAuth2.0 提供商的网站上注册我们的应用程序，并获取客户端 ID 和密钥。例如，我们可以在 Google Cloud Console 中创建并注册一个新的项目，然后选择“创建凭证”以获取我们的客户端 ID 和密钥。

第二步：设置客户端设置

我们需要设置一个客户端配置才能使用OAuth2.0进行身份验证。我们可以通过创建一个 oauth2.Config 对象来实现此目的：

import (
    "golang.org/x/oauth2"
)

var (
    clientID     = "YOUR_CLIENT_ID"
    clientSecret = "YOUR_CLIENT_SECRET"
    redirectURL  = "http://localhost:8080/callback"
    endpoint     = google.Endpoint
    scopes       = []string{"https://www.googleapis.com/auth/userinfo.profile", "https://www.googleapis.com/auth/userinfo.email"}
)

var (
    oauth2Config = oauth2.Config{
        ClientID:     clientID,
        ClientSecret: clientSecret,
        RedirectURL:  redirectURL,
        Endpoint:     endpoint,
        Scopes:       scopes,
    }
)

在上面的示例中，我们定义了客户端 ID、客户端密钥、重定向 URL，OAuth2.0 结束点和作用域。这里的 endpoint 来自 google.Endpoint，它是一个预定义的 OAuth2.0 提供商基础结构。

第三步：重定向到授权页面

现在我们已经设置了客户端配置，我们需要将用户重定向到 OAuth2.0 授权页面。我们可以使用 oauth2Config.AuthCodeURL 方法来获取授权 URL。以下是一个示例：

import (
    "fmt"
    "net/http"
)

func handleAuthorize(w http.ResponseWriter, r *http.Request) {
    url := oauth2Config.AuthCodeURL("")
    http.Redirect(w, r, url, http.StatusFound)
}

在上面的示例中，我们使用 oauth2Config.AuthCodeURL("") 方法获取授权 URL，然后使用 http.Redirect 将用户重定向到授权页面。

第四步：处理回调

一旦用户同意授权我们的应用程序，OAuth2.0 提供程序将重定向用户到我们提供的重定向 URL。在重定向 URL 中，我们将包含一个授权代码，我们需要使用它来获取访问令牌。

我们需要定义一个回调处理程序来处理 OAuth2.0 提供程序的回调请求。以下是一个示例：

func handleOAuth2Callback(w http.ResponseWriter, r *http.Request) {
    code := r.FormValue("code")
    token, err := oauth2Config.Exchange(oauth2.NoContext, code)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    client := oauth2Config.Client(oauth2.NoContext, token)
    resp, err := client.Get("https://www.googleapis.com/oauth2/v1/userinfo?alt=json")
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer resp.Body.Close()

    data, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    fmt.Fprintf(w, "Data: %s", data)
}

在上面的示例中，我们首先从回调中提取授权代码，然后使用 oauth2Config.Exchange 方法来获取访问令牌。我们可以使用 oauth2Config.Client 方法创建一个认证 HTTP 客户端，并使用该客户端来调用 Google OAuth2.0 API。

最后我们可以通过写入 datarrreee

Dans l'exemple ci-dessus, nous avons défini une fonction BasicAuth qui vérifie que le nom d'utilisateur et le mot de passe correspondent à ceux fournis par r.BasicAuth() Credentials match. Si aucune information d'identification n'est fournie ou si les informations d'identification fournies sont incorrectes, une réponse HTTP 401 non autorisée est déclenchée. Si les informations d'identification sont vérifiées avec succès, la fonction handler est appelée.

En plus de cet exemple d'authentification de base, il est également possible d'utiliser des bibliothèques d'authentification fournies par des packages appartenant à d'autres tiers, tels que Gorilla Toolkit.

Authentification OAuth 2.0🎜🎜OAuth2.0 est une norme ouverte pour le processus permettant à des tiers d'accéder aux ressources des utilisateurs autorisés. Dans Golang, nous pouvons utiliser le package go-oauth2/oauth2 pour implémenter l'authentification OAuth 2.0. 🎜

Étape 1 : Enregistrez l'application et obtenez l'ID client et la clé

🎜Nous devons d'abord enregistrer notre application sur le site Web du fournisseur OAuth2.0 et obtenir l'ID client et la clé. Par exemple, nous pouvons créer et enregistrer un nouveau projet dans Google Cloud Console et sélectionner « Créer des informations d'identification » pour obtenir notre identifiant client et notre secret. 🎜

Étape 2 : Définir les paramètres du client

🎜Nous devons configurer une configuration client pour nous authentifier à l'aide d'OAuth2.0. Nous pouvons y parvenir en créant un objet oauth2.Config : 🎜rrreee🎜 Dans l'exemple ci-dessus, nous avons défini l'ID client, le secret client, l'URL de redirection et la fin des points et portées OAuth2.0. Le endpoint ici provient de google.Endpoint, qui est une infrastructure de fournisseur OAuth2.0 prédéfinie. 🎜

Étape 3 : Redirection vers la page d'autorisation

🎜Maintenant que nous avons configuré la configuration du client, nous devons rediriger l'utilisateur vers la page d'autorisation OAuth2.0. Nous pouvons utiliser la méthode oauth2Config.AuthCodeURL pour obtenir l'URL d'autorisation. Voici un exemple : 🎜rrreee🎜Dans l'exemple ci-dessus, nous utilisons la méthode oauth2Config.AuthCodeURL("") pour obtenir l'URL d'autorisation, puis utilisons http.Redirect pour rediriger l'utilisateur dirigé vers la page d'autorisation. 🎜

Étape 4 : Gérer le rappel

🎜Une fois que l'utilisateur accepte d'autoriser notre application, le fournisseur OAuth2.0 redirigera l'utilisateur vers l'URL de redirection que nous avons fournie. Dans l'URL de redirection, nous inclurons un code d'autorisation que nous devons utiliser pour obtenir le jeton d'accès. 🎜🎜Nous devons définir un gestionnaire de rappel pour gérer les demandes de rappel du fournisseur OAuth2.0. Voici un exemple : 🎜rrreee🎜 Dans l'exemple ci-dessus, nous extrayons d'abord le code d'autorisation du rappel, puis utilisons la méthode oauth2Config.Exchange pour obtenir le jeton d'accès. Nous pouvons utiliser la méthode oauth2Config.Client pour créer un client HTTP authentifié et utiliser ce client pour appeler l'API Google OAuth2.0. 🎜🎜Enfin nous pouvons répondre à la requête en écrivant les données de réponse dans la variable data. 🎜🎜Conclusion🎜🎜Dans cet article, nous avons présenté deux façons d'implémenter l'authentification dans Golang : l'authentification de base et l'authentification OAuth 2.0. En utilisant ces méthodes, nous pouvons garantir que notre application est sécurisée et autorise uniquement l'accès aux utilisateurs de confiance. 🎜

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!