Créez un système d'authentification sécurisé à l'aide de Golang et Vault

Créer un système d'authentification sécurisé à l'aide de Golang et Vault

À l'ère d'Internet d'aujourd'hui, protéger la sécurité des données des utilisateurs est devenu une tâche très importante. L'authentification, en tant que première ligne de défense pour protéger les données des utilisateurs, est un module essentiel pour toute application. Pour garantir la sécurité de l'authentification, nous pouvons utiliser Golang et Vault pour créer un système d'authentification sécurisé.

Vault est un outil open source développé par HashiCorp pour la gestion sécurisée et la protection des données sensibles, telles que les clés API, les mots de passe, les certificats, etc. Il dispose de fonctions de gestion des clés, d'authentification, de contrôle d'accès et d'autres fonctions, qui peuvent nous aider à créer un système d'authentification puissant et sécurisé.

Tout d'abord, nous devons installer et configurer Vault. Vous pouvez le télécharger depuis le site officiel de HashiCorp et l'installer et le configurer selon la documentation officielle. Une fois installé, nous pouvons interagir avec Vault via l'API HTTP REST ou le SDK Golang.

Ensuite, nous écrirons un système d'authentification simple utilisant Golang. Tout d’abord, nous devons présenter le SDK Golang de Vault. Il peut être installé à l'aide de la commande suivante :

go get github.com/hashicorp/vault/api

Ensuite, nous devons importer le SDK Golang de Vault :

import (
    "github.com/hashicorp/vault/api"
)

Ensuite, nous devons configurer la connexion à Vault. Tout d’abord, nous devons obtenir le jeton Vault. Vous pouvez créer un jeton sur l'interface Web de Vault et l'enregistrer dans un fichier de configuration, puis le lire dans votre code. Veuillez noter qu'ici, nous codons uniquement en dur le jeton directement dans le code à des fins de démonstration. En pratique, veuillez suivre les meilleures pratiques.

config := &api.Config{
    Address: "http://localhost:8200",
}

client, err := api.NewClient(config)
if err != nil {
    log.Fatal(err)
}

client.SetToken("your_vault_token")

Maintenant que nous sommes connectés avec succès à Vault, nous allons créer une fonction d'authentification simple. Nous pouvons utiliser le moteur de stockage K/V de Vault pour stocker des paires clé-valeur de noms d'utilisateur et de mots de passe. Tout d’abord, nous devons créer un chemin de stockage secret pour le moteur de stockage K/V.

path := "/secret/userinfo"

data := map[string]interface{}{
    "username": "admin",
    "password": "password123",
}

_, err := client.Logical().Write(path, data)
if err != nil {
    log.Fatal(err)
}

Maintenant que nous avons stocké le nom d'utilisateur et le mot de passe dans le coffre-fort, nous allons écrire une fonction de validation pour vérifier que le nom d'utilisateur et le mot de passe saisis par l'utilisateur sont corrects.

func authenticate(username, password string) bool {
    path := "/secret/userinfo"

    secret, err := client.Logical().ReadWithData(path, map[string]interface{}{"key": "value"})
    if err != nil {
        log.Fatal(err)
    }

    storedUsername := secret.Data["username"].(string)
    storedPassword := secret.Data["password"].(string)

    if username == storedUsername && password == storedPassword {
        return true
    }

    return false
}

Dans le code ci-dessus, nous utilisons d'abord l'API de Vault pour lire le nom d'utilisateur et le mot de passe stockés. Nous comparons ensuite le nom d'utilisateur et le mot de passe saisis par l'utilisateur avec les valeurs stockées. Renvoie vrai s'il y a une correspondance, faux sinon.

Nous pouvons désormais utiliser la fonction d'authentification ci-dessus pour vérifier l'identité de l'utilisateur.

username := "admin"
password := "password123"

result := authenticate(username, password)

if result {
    fmt.Println("Authentication succeeded")
} else {
    fmt.Println("Authentication failed")
}

Dans le code ci-dessus, nous transmettons le nom d'utilisateur et le mot de passe à la fonction d'authentification pour l'authentification. Sur la base des résultats renvoyés, nous générons les informations correspondantes.

En utilisant Golang et Vault, nous pouvons créer un système d'authentification sécurisé et fort. Les fonctions puissantes de Vault peuvent nous aider à protéger la sécurité des données des utilisateurs, tandis que la simplicité et l'efficacité de Golang rendent le processus de développement plus fluide.

Exemple de code complet :

package main

import (
    "fmt"
    "log"

    "github.com/hashicorp/vault/api"
)

func main() {
    config := &api.Config{
        Address: "http://localhost:8200",
    }

    client, err := api.NewClient(config)
    if err != nil {
        log.Fatal(err)
    }

    client.SetToken("your_vault_token")

    path := "/secret/userinfo"

    data := map[string]interface{}{
        "username": "admin",
        "password": "password123",
    }

    _, err = client.Logical().Write(path, data)
    if err != nil {
        log.Fatal(err)
    }

    username := "admin"
    password := "password123"

    result := authenticate(client, username, password)

    if result {
        fmt.Println("Authentication succeeded")
    } else {
        fmt.Println("Authentication failed")
    }
}

func authenticate(client *api.Client, username, password string) bool {
    path := "/secret/userinfo"

    secret, err := client.Logical().ReadWithData(path, map[string]interface{}{})
    if err != nil {
        log.Fatal(err)
    }

    storedUsername := secret.Data["username"].(string)
    storedPassword := secret.Data["password"].(string)

    if username == storedUsername && password == storedPassword {
        return true
    }

    return false
}

Dans cet article, nous avons construit un système d'authentification simple et sécurisé utilisant Golang et Vault. En utilisant l'API de Vault, nous pouvons facilement stocker des données sensibles dans Vault et utiliser Golang pour authentifier les utilisateurs. De cette façon, nous garantissons la sécurité des données de nos utilisateurs et fournissons un processus d'authentification solide et sécurisé.

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!