Golang dans la gestion des mots de passe : obtention et stockage des clés de cryptage à partir de Vault

Golang dans la gestion des mots de passe : obtention et stockage des clés de cryptage à partir de Vault

Introduction :
Dans le développement de logiciels modernes, la sécurité est un aspect crucial. Le stockage et l’utilisation sécurisés des clés de chiffrement sont essentiels à la gestion des mots de passe. Dans cet article, nous verrons comment obtenir et stocker des clés de chiffrement à l'aide de Golang et Vault.

Qu'est-ce que Vault ?
Vault est un outil open source développé par HashiCorp pour stocker et accéder en toute sécurité aux secrets, mots de passe et données sensibles. Vault fournit une gamme de fonctionnalités, notamment le contrôle d'accès basé sur les rôles, le stockage chiffré, l'automatisation des secrets, les journaux d'audit, etc. En utilisant Vault, nous pouvons stocker de manière centralisée les données sensibles dans un endroit sûr et fournir un accès sécurisé aux applications et services.

Utilisez Vault pour obtenir la clé de cryptage :
Tout d'abord, nous devons installer et configurer Vault. Vous pouvez vous référer à la documentation officielle de Vault pour fonctionner. Une fois installé, nous pouvons utiliser Golang pour interagir avec Vault.

En utilisant Vault dans Golang, nous pouvons utiliser l'API de Vault pour obtenir la clé de cryptage. Tout d'abord, nous devons importer le package Vault et les autres bibliothèques nécessaires :

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

Ensuite, nous pouvons écrire une fonction pour obtenir la clé de cryptage :

func getEncryptionKey() (string, error) {
    config := &api.Config{
        Address: "http://localhost:8200", // 替换为Vault的地址
    }

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

    // 设置Vault的访问令牌
    client.SetToken("YOUR_VAULT_TOKEN")

    // 从Vault中获取加密密钥
    secret, err := client.Logical().Read("secret/data/encryption-key")
    if err != nil {
        return "", err
    }

    if secret != nil && secret.Data != nil {
        if key, ok := secret.Data["key"].(string); ok {
            return key, nil
        }
    }

    return "", fmt.Errorf("encryption key not found")
}

Dans le code ci-dessus, nous créons d'abord un client Vault et définissons l'adresse et l'accès. jeton du coffre-fort. Nous utilisons ensuite la méthode client.Logical().Read pour obtenir la clé de chiffrement du coffre-fort. Enfin, nous extrayons la clé de chiffrement des données de réponse de Vault et la renvoyons. client.Logical().Read方法从Vault中获取加密密钥。最后，我们从Vault的响应数据中提取加密密钥并返回。

使用Vault存储加密密钥：
除了从Vault中获取加密密钥，我们还可以使用Vault将加密密钥安全地存储起来。接下来，我们将演示如何使用Golang来存储加密密钥。

首先，我们需要编写一个函数来将加密密钥存储到Vault中：

func storeEncryptionKey(key string) error {
    config := &api.Config{
        Address: "http://localhost:8200", // 替换为Vault的地址
    }

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

    // 设置Vault的访问令牌
    client.SetToken("YOUR_VAULT_TOKEN")

    // 将加密密钥存储到Vault中
    data := map[string]interface{}{
        "key": key,
    }

    _, err = client.Logical().Write("secret/data/encryption-key", data)
    if err != nil {
        return err
    }

    return nil
}

在上面的代码中，我们首先创建了一个Vault客户端，并设置了Vault的地址和访问令牌。然后，我们使用client.Logical().Write方法将加密密钥存储到Vault中。

使用：
现在我们已经学会了如何获取和存储加密密钥，我们可以在我们的应用程序中使用这些函数来增强密码管理的安全性。

下面是一个示例，演示了如何在Golang中使用Vault的加密密钥来对密码进行加密和解密：

import (
    "encoding/base64"
    "fmt"
    "github.com/awnumar/memguard"
)

func encryptPassword(password string) (string, error) {
    key, err := getEncryptionKey()
    if err != nil {
        return "", err
    }

    guardedKey := memguard.NewBufferFromBytes([]byte(key))
    defer memguard.PurgeBuffer(guardedKey)

    ciphertext, err := aesEncrypt([]byte(password), guardedKey.Buffer())
    if err != nil {
        return "", err
    }

    encodedCiphertext := base64.StdEncoding.EncodeToString(ciphertext)

    return encodedCiphertext, nil
}

func decryptPassword(encodedCiphertext string) (string, error) {
    key, err := getEncryptionKey()
    if err != nil {
        return "", err
    }

    guardedKey := memguard.NewBufferFromBytes([]byte(key))
    defer memguard.PurgeBuffer(guardedKey)

    ciphertext, err := base64.StdEncoding.DecodeString(encodedCiphertext)
    if err != nil {
        return "", err
    }

    plaintext, err := aesDecrypt(ciphertext, guardedKey.Buffer())
    if err != nil {
        return "", err
    }

    return string(plaintext), nil
}

func main() {
    // 加密密码
    encryptedPassword, err := encryptPassword("mySecretPassword")
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println("Encrypted Password:", encryptedPassword)

    // 解密密码
    decryptedPassword, err := decryptPassword(encryptedPassword)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println("Decrypted Password:", decryptedPassword)
}

在上面的代码中，我们首先使用getEncryptionKey

Utilisez Vault pour stocker les clés de chiffrement :

En plus d'obtenir les clés de chiffrement de Vault, nous pouvons également utiliser Vault pour stocker les clés de chiffrement en toute sécurité. Ensuite, nous montrerons comment utiliser Golang pour stocker les clés de chiffrement.

Tout d'abord, nous devons écrire une fonction pour stocker la clé de cryptage dans le Vault : 🎜rrreee🎜Dans le code ci-dessus, nous créons d'abord un client Vault et configurons l'adresse et le jeton d'accès du Vault. Nous utilisons ensuite la méthode client.Logical().Write pour stocker la clé de chiffrement dans le coffre-fort. 🎜🎜Utilisation : 🎜Maintenant que nous avons appris comment obtenir et stocker des clés de cryptage, nous pouvons utiliser ces fonctions dans nos applications pour améliorer la sécurité de la gestion des mots de passe. 🎜🎜Voici un exemple qui montre comment utiliser la clé de cryptage de Vault pour crypter et déchiffrer les mots de passe dans Golang : 🎜rrreee🎜Dans le code ci-dessus, nous utilisons d'abord la fonction getEncryptionKey de Vault. Obtenez la clé de cryptage de . Nous utilisons ensuite cette clé pour crypter le mot de passe, puis le déchiffrer. Enfin, nous imprimons le mot de passe crypté et déchiffré. 🎜🎜Conclusion : 🎜Dans cet article, nous avons expliqué comment obtenir et stocker des clés de chiffrement à l'aide de Golang et Vault. Nous utilisons l'API de Vault pour interagir avec Vault et montrons comment utiliser les clés de chiffrement de Vault pour chiffrer et déchiffrer les mots de passe dans Golang. En utilisant correctement Vault, nous pouvons améliorer la sécurité de la gestion des mots de passe et protéger les données sensibles. J'espère que cet article vous aidera à comprendre l'application de Golang dans la gestion des mots de passe. 🎜

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!