密碼雜湊和金鑰派生：將秘密變成安全的亂碼，Go Crypto 8-Golang-PHP中文網

Password Hashing and Key Derivation: Turning Secrets into Secure Gibberish, Go Crypto 8

嘿，加密貨幣冠軍！準備好深入密碼雜湊和金鑰派生的世界了嗎？將這些視為將密碼和金鑰變成安全、不可讀的亂碼的秘訣。讓我們看看 Go 如何幫助我們創造一些加密魔法！

密碼哈希：使密碼不可讀（甚至對我們來說也是如此！）

首先，我們來談談密碼雜湊。這就像將密碼放入加密混合器中 - 結果看起來與輸入的完全不同，而這正是我們想要的！

Bcrypt：經典密碼冰沙

Bcrypt 就像密碼雜湊的經典冰沙 - 經過嘗試、測試，仍然美味。使用方法如下：

import (
    "fmt"
    "golang.org/x/crypto/bcrypt"
)

func main() {
    password := []byte("iLoveCrypto123")

    // Let's blend this password!
    hashedPassword, err := bcrypt.GenerateFromPassword(password, bcrypt.DefaultCost)
    if err != nil {
        panic("Our cryptographic blender broke!")
    }

    fmt.Printf("Our password smoothie: %x\n", hashedPassword)

    // Now, let's see if we can recognize our original password
    err = bcrypt.CompareHashAndPassword(hashedPassword, password)
    if err != nil {
        fmt.Println("Nope, that's not our password!")
    } else {
        fmt.Println("Yep, that's our password alright!")
    }
}

登入後複製

Argon2：更新、更精緻的冰沙

Argon2 就像包含所有超級食物的新型冰沙 - 它的設計對現代密碼破解技術具有額外的抵抗力。使用方法如下：

import (
    "crypto/rand"
    "encoding/base64"
    "fmt"
    "golang.org/x/crypto/argon2"
)

func main() {
    password := []byte("iLoveCryptoEvenMore456")

    // First, let's add some salt to our smoothie
    salt := make([]byte, 16)
    if _, err := rand.Read(salt); err != nil {
        panic("Our salt shaker is empty!")
    }

    // Now, let's blend our password
    timeCost := uint32(1)
    memoryCost := uint32(64 * 1024)
    threads := uint8(4)
    keyLength := uint32(32)

    hash := argon2.IDKey(password, salt, timeCost, memoryCost, threads, keyLength)

    // Let's encode our smoothie and salt for storage
    encodedHash := base64.RawStdEncoding.EncodeToString(hash)
    encodedSalt := base64.RawStdEncoding.EncodeToString(salt)

    fmt.Printf("Our fancy password smoothie: %s\n", encodedHash)
    fmt.Printf("Our salt: %s\n", encodedSalt)

    // To verify, we'd need to decode the salt, reblend with the same recipe, and compare
}

登入後複製

金鑰派生：將密碼轉換為加密金鑰

現在，我們來談談金鑰派生。這就像將簡單的密碼變成可以解鎖我們的加密寶藏的複雜密鑰。

PBKDF2：經典鑰匙製作器

PBKDF2 就像一台古老、可靠的鑰匙切割機。它會獲取您的密碼並將其變成閃亮的新密鑰。方法如下：

import (
    "crypto/rand"
    "crypto/sha256"
    "encoding/base64"
    "fmt"
    "golang.org/x/crypto/pbkdf2"
)

func main() {
    password := []byte("OpenSesame123")

    // Let's add some randomness to our key-making process
    salt := make([]byte, 16)
    if _, err := rand.Read(salt); err != nil {
        panic("Our randomness generator broke!")
    }

    // Time to make our key
    iterations := 100000
    keyLength := 32
    key := pbkdf2.Key(password, salt, iterations, keyLength, sha256.New)

    // Let's encode our new key and salt
    encodedKey := base64.RawStdEncoding.EncodeToString(key)
    encodedSalt := base64.RawStdEncoding.EncodeToString(salt)

    fmt.Printf("Our shiny new key: %s\n", encodedKey)
    fmt.Printf("The salt we used: %s\n", encodedSalt)
}

登入後複製

HKDF：關鍵工廠

HKDF 就像一個神奇的鑰匙工廠，可以從一個秘密中生產多個鑰匙。當您需要多把鑰匙用於不同目的時，它是完美的選擇。使用方法如下：

import (
    "crypto/sha256"
    "encoding/base64"
    "fmt"
    "golang.org/x/crypto/hkdf"
    "io"
)

func main() {
    secret := []byte("MySuper
SecretValue")
    salt := []byte("SaltySalt")
    info := []byte("KeyForEncryption")

    // Let's start up our key factory
    keyFactory := hkdf.New(sha256.New, secret, salt, info)

    // Now, let's produce two 32-byte keys
    key1 := make([]byte, 32)
    key2 := make([]byte, 32)

    if _, err := io.ReadFull(keyFactory, key1); err != nil {
        panic("Our key factory had a malfunction!")
    }
    if _, err := io.ReadFull(keyFactory, key2); err != nil {
        panic("Our key factory is tired and can't make another key!")
    }

    // Let's encode our new keys
    encodedKey1 := base64.RawStdEncoding.EncodeToString(key1)
    encodedKey2 := base64.RawStdEncoding.EncodeToString(key2)

    fmt.Printf("Our first key: %s\n", encodedKey1)
    fmt.Printf("Our second key: %s\n", encodedKey2)
}

登入後複製