Implementasi Kaedah Standard Symmetric Encryption Signature pada Golang

Apakah Kaedah Tandatangan Penyulitan Symmetric Standard?

Jadi, anda lihat, kaedah ini adalah cara untuk menyulitkan data supaya ia selamat dan tidak boleh dibaca oleh orang yang tidak mempunyai kunci penyahsulitan. Cuba bayangkan, kawan-kawan, anda mempunyai diari yang anda kunci dengan gembok. Hanya orang yang mempunyai kunci boleh membuka dan membaca diari anda.

Penyulitan simetri

Symmetric encryption ni macam kawan dan kawan, apa ni, hahaha, intinya, macam ada kunci yang sama untuk buka kunci. Kunci ini digunakan untuk data penyulitan (mengunci) dan penyahsulitan (membuka kunci). Jadi, kedua-dua rakan dan rakan boleh mengunci dan membuka kunci data yang sama selagi anda mempunyai kunci.

Tandatangan

Tandatangan di sini bukan tandatangan fizikal, tetapi lebih kepada tandatangan digital. Tandatangan ini memastikan bahawa data yang dihantar adalah benar-benar daripada rakan-rakan dan tiada siapa yang mengubah data di tengah jalan. Jadi, kawan-kawan, anda boleh pastikan bahawa data yang anda terima adalah tulen daripada sumbernya dan tidak diusik.

Mengapa anda perlu menggunakan kaedah ini?

• Keselamatan Data: Pasti anda mahu data anda selamat daripada tangan yang berniat jahat, bukan? Dengan penyulitan simetri, data anda disulitkan dan hanya boleh dibuka oleh orang yang mempunyai kunci.
• Integriti Data: Dengan tandatangan, anda boleh memastikan bahawa data yang anda terima atau hantar adalah tulen dan tidak diusik. Jadi, kawan-kawan, anda tidak perlu risau tentang seseorang yang menipu.
• Kecekapan: Penyulitan simetri biasanya lebih pantas daripada Penyulitan Asimetri kerana proses penyulitan dan penyahsulitan lebih mudah.

Contoh Penggunaan di Golang

Sekarang mari kita lihat cara menggunakan kaedah ini di Golang.

Penyulitan simetri di Golang

package main

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "encoding/hex"
    "fmt"
    "io"
)

func encrypt(key, text []byte) (string, error) {
    block, err := aes.NewCipher(key)
    if err != nil {
        return "", err
    }

    ciphertext := make([]byte, aes.BlockSize+len(text))
    iv := ciphertext[:aes.BlockSize]
    if _, err := io.ReadFull(rand.Reader, iv); err != nil {
        return "", err
    }

    stream := cipher.NewCFBEncrypter(block, iv)
    stream.XORKeyStream(ciphertext[aes.BlockSize:], text)

    return fmt.Sprintf("%x", ciphertext), nil
}

func decrypt(key []byte, cryptoText string) (string, error) {
    ciphertext, _ := hex.DecodeString(cryptoText)

    block, err := aes.NewCipher(key)
    if err != nil {
        return "", err
    }

    if len(ciphertext) < aes.BlockSize {
        return "", fmt.Errorf("ciphertext too short")
    }
    iv := ciphertext[:aes.BlockSize]
    ciphertext = ciphertext[aes.BlockSize:]

    stream := cipher.NewCFBDecrypter(block, iv)
    stream.XORKeyStream(ciphertext, ciphertext)

    return string(ciphertext), nil
}

func main() {
    key := []byte("the-key-has-to-be-32-bytes-long!")
    plaintext := "hello, world!"

    ciphertext, err := encrypt(key, []byte(plaintext))
    if err != nil {
        fmt.Println("Error encrypting:", err)
        return
    }
    fmt.Printf("Encrypted: %s\n", ciphertext)

    decryptedText, err := decrypt(key, ciphertext)
    if err != nil {
        fmt.Println("Error decrypting:", err)
        return
    }
    fmt.Printf("Decrypted: %s\n", decryptedText)
}

Signature Golang

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
)

func createHMAC(key, message []byte) string {
    mac := hmac.New(sha256.New, key)
    mac.Write(message)
    return hex.EncodeToString(mac.Sum(nil))
}

func verifyHMAC(key, message []byte, signature string) bool {
    expectedMAC := createHMAC(key, message)
    return hmac.Equal([]byte(expectedMAC), []byte(signature))
}

func main() {
    key := []byte("my-secret-key")
    message := []byte("important message")

    signature := createHMAC(key, message)
    fmt.Printf("Signature: %s\n", signature)

    isValid := verifyHMAC(key, message, signature)
    fmt.Printf("Is valid: %t\n", isValid)
}

Jadi Kaedah Tandatangan Penyulitan Symmetric Standard adalah penting untuk mengekalkan keselamatan dan integriti data anda. Dengan penyulitan simetri, anda boleh menyulitkan data anda untuk menjadikannya selamat, dan dengan tandatangan, anda boleh memastikan bahawa data yang anda terima atau hantar adalah tulen dan tidak diusik. Jadi, pastikan kawan-kawan menggunakan kaedah ini untuk semua jenis keperluan yang memerlukan keselamatan yang tinggi.

Sumber:

• HMAC Go
• SHA256

Atas ialah kandungan terperinci Implementasi Kaedah Standard Symmetric Encryption Signature pada Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!