Bina sistem pengesahan selamat menggunakan Golang dan Vault

Membina sistem pengesahan selamat menggunakan Golang dan Vault

Dalam era Internet hari ini, melindungi keselamatan data pengguna telah menjadi tugas yang sangat penting. Pengesahan, sebagai barisan pertahanan pertama untuk melindungi data pengguna, adalah modul penting untuk sebarang aplikasi. Untuk memastikan keselamatan pengesahan, kami boleh menggunakan Golang dan Vault untuk membina sistem pengesahan yang selamat.

Vault ialah alat sumber terbuka yang dibangunkan oleh HashiCorp, digunakan untuk mengurus dan melindungi data sensitif dengan selamat, seperti kunci API, kata laluan, sijil, dsb. Ia mempunyai pengurusan utama, pengesahan, kawalan akses dan fungsi lain, yang boleh membantu kami membina sistem pengesahan yang berkuasa dan selamat.

Pertama, kita perlu memasang dan mengkonfigurasi Vault. Anda boleh memuat turunnya dari laman web rasmi HashiCorp dan memasang serta mengkonfigurasinya mengikut dokumentasi rasmi. Setelah dipasang, kami boleh berinteraksi dengan Vault melalui HTTP REST API atau Golang SDK.

Seterusnya, kami akan menulis sistem pengesahan mudah menggunakan Golang. Pertama, kita perlu memperkenalkan SDK Golang Vault. Ia boleh dipasang menggunakan arahan berikut:

go get github.com/hashicorp/vault/api

Kemudian, kita perlu mengimport SDK Golang Vault:

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

Seterusnya, kita perlu menyediakan sambungan ke Vault. Pertama, kita perlu mendapatkan token Vault. Anda boleh membuat token pada antara muka web Vault dan menyimpannya dalam fail konfigurasi dan kemudian membacanya dalam kod anda. Sila ambil perhatian bahawa di sini kami hanya mengekod token terus ke dalam kod untuk tujuan demonstrasi, sila ikuti amalan terbaik.

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

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

client.SetToken("your_vault_token")

Sekarang kami telah berjaya menyambung ke Vault, kami akan mencipta fungsi pengesahan yang mudah. Kami boleh menggunakan enjin storan K/V Vault untuk menyimpan pasangan nilai kunci nama pengguna dan kata laluan. Pertama, kita perlu mencipta laluan storan rahsia untuk enjin storan 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)
}

Sekarang kami telah menyimpan nama pengguna dan kata laluan dalam Vault, kami akan menulis fungsi pengesahan untuk mengesahkan bahawa nama pengguna dan kata laluan yang dimasukkan oleh pengguna adalah betul.

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
}

Dalam kod di atas, kami mula-mula menggunakan API Vault untuk membaca nama pengguna dan kata laluan yang disimpan. Kami kemudian membandingkan nama pengguna dan kata laluan yang dimasukkan oleh pengguna dengan nilai yang disimpan. Mengembalikan benar jika terdapat padanan, palsu sebaliknya.

Kini kita boleh menggunakan fungsi pengesahan di atas untuk mengesahkan identiti pengguna.

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

result := authenticate(username, password)

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

Dalam kod di atas, kami menghantar nama pengguna dan kata laluan kepada fungsi pengesahan untuk pengesahan. Berdasarkan keputusan yang dikembalikan, kami mengeluarkan maklumat yang sepadan.

Dengan menggunakan Golang dan Vault, kami boleh membina sistem pengesahan yang selamat dan kukuh. Fungsi berkuasa Vault boleh membantu kami melindungi keselamatan data pengguna, manakala kesederhanaan dan kecekapan Golang menjadikan proses pembangunan lebih lancar.

Contoh Kod Penuh:

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
}

Dalam siaran ini, kami membina sistem pengesahan yang mudah dan selamat menggunakan Golang dan Vault. Dengan menggunakan API Vault, kami boleh menyimpan data sensitif dalam Vault dengan mudah dan menggunakan Golang untuk mengesahkan pengguna. Dengan cara ini, kami memastikan keselamatan data pengguna kami dan menyediakan proses pengesahan yang kukuh dan selamat.

Atas ialah kandungan terperinci Bina sistem pengesahan selamat menggunakan Golang dan Vault. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!