Golang dalam Pengurusan Kata Laluan: Mendapatkan dan Menyimpan Kunci Penyulitan daripada Vault

Golang dalam Pengurusan Kata Laluan: Mendapatkan dan Menyimpan Kunci Penyulitan daripada Vault

Pengenalan:
Dalam pembangunan perisian moden, keselamatan merupakan aspek yang penting. Penyimpanan selamat dan penggunaan kunci penyulitan adalah penting untuk pengurusan kata laluan. Dalam siaran ini, kami akan membincangkan cara mendapatkan dan menyimpan kunci penyulitan menggunakan Golang dan Vault.

Apakah itu Vault?
Vault ialah alat sumber terbuka yang dibangunkan oleh HashiCorp untuk menyimpan dan mengakses rahsia, kata laluan dan data sensitif dengan selamat. Vault menyediakan pelbagai ciri, termasuk kawalan akses berasaskan peranan, storan yang disulitkan, automasi rahsia, log audit dan banyak lagi. Dengan menggunakan Vault, kami boleh menyimpan data sensitif secara berpusat di tempat yang selamat dan menyediakan akses selamat kepada aplikasi dan perkhidmatan.

Gunakan Vault untuk mendapatkan kunci penyulitan:
Pertama, kami perlu memasang dan mengkonfigurasi Vault Anda boleh merujuk kepada dokumentasi rasmi Vault untuk beroperasi. Setelah dipasang, kami boleh menggunakan Golang untuk berinteraksi dengan Vault.

Menggunakan Vault di Golang, kami boleh menggunakan API Vault untuk mendapatkan kunci penyulitan. Pertama, kita perlu mengimport pakej bilik kebal dan perpustakaan lain yang diperlukan:

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

Seterusnya, kita boleh menulis fungsi untuk mendapatkan kunci penyulitan:

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")
}

Dalam kod di atas, kami mula-mula mencipta klien Vault dan menetapkan alamat Bilik Kebal dan token akses. Kami kemudian menggunakan kaedah client.Logical().Read untuk mendapatkan kunci penyulitan daripada Vault. Akhir sekali, kami mengekstrak kunci penyulitan daripada data respons Vault dan mengembalikannya. 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

Gunakan Vault untuk menyimpan kunci penyulitan:

Selain mendapatkan kunci penyulitan daripada Vault, kami juga boleh menggunakan Vault untuk menyimpan kunci penyulitan dengan selamat. Seterusnya, kami akan menunjukkan cara menggunakan Golang untuk menyimpan kunci penyulitan.

Mula-mula, kita perlu menulis fungsi untuk menyimpan kunci penyulitan ke dalam Bilik Kebal: 🎜rrreee🎜Dalam kod di atas, kami mula-mula membuat klien Vault dan menyediakan alamat dan token akses Vault. Kami kemudian menggunakan kaedah client.Logical().Write untuk menyimpan kunci penyulitan ke dalam Bilik Kebal. 🎜🎜Penggunaan: 🎜Sekarang kami telah mempelajari cara mendapatkan dan menyimpan kunci penyulitan, kami boleh menggunakan fungsi ini dalam aplikasi kami untuk meningkatkan keselamatan pengurusan kata laluan. 🎜🎜Berikut ialah contoh yang menunjukkan cara menggunakan kunci penyulitan Vault untuk menyulitkan dan menyahsulit kata laluan di Golang: 🎜rrreee🎜Dalam kod di atas, kami mula-mula menggunakan fungsi getEncryptionKey daripada Vault Dapatkan kunci penyulitan daripada . Kami kemudian menggunakan kunci itu untuk menyulitkan kata laluan dan kemudian menyahsulitnya. Akhirnya, kami mencetak kata laluan yang disulitkan dan dinyahsulit. 🎜🎜Kesimpulan: 🎜Dalam artikel ini, kami membincangkan cara mendapatkan dan menyimpan kunci penyulitan menggunakan Golang dan Vault. Kami menggunakan API Vault untuk berinteraksi dengan Vault dan menunjukkan cara menggunakan kunci penyulitan Vault untuk menyulitkan dan menyahsulit kata laluan di Golang. Dengan menggunakan Vault dengan betul, kami boleh meningkatkan keselamatan pengurusan kata laluan dan melindungi data sensitif. Saya harap artikel ini akan membantu anda memahami aplikasi Golang dalam pengurusan kata laluan. 🎜

Atas ialah kandungan terperinci Golang dalam Pengurusan Kata Laluan: Mendapatkan dan Menyimpan Kunci Penyulitan daripada Vault. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!