Implementieren Sie die Methode „Standard Symmetric Encryption Signature“ von Golang

Was ist die standardmäßige symmetrische Verschlüsselungssignaturmethode?

Sie sehen also, diese Methode ist eine Möglichkeit, Daten so zu verschlüsseln, dass sie sicher sind und nicht von Personen gelesen werden können, die nicht über den Entschlüsselungsschlüssel verfügen. Stellen Sie sich vor, Freunde, Sie haben ein Tagebuch, das Sie mit einem Vorhängeschloss verschließen. Nur Personen, die den Schlüssel haben, können Ihre Tagebücher öffnen und lesen.

Symmetrische Verschlüsselung

Symmetrische Verschlüsselung ist wie Freunde und Freunde, was ist das, hahaha, der Punkt ist, es ist, als hätte man den gleichen Schlüssel, um das Schloss zu öffnen. Dieser Schlüssel wird zum Verschlüsseln (Sperren) und Entschlüsseln (Entsperren) von Daten verwendet. So können sowohl Freunde als auch Freunde dieselben Daten sperren und entsperren, solange Sie den Schlüssel haben.

Unterschrift

Die Signatur ist hier keine physische Signatur, sondern eher eine digitale Signatur. Diese Signatur stellt sicher, dass die gesendeten Daten tatsächlich von Freunden stammen und niemand die Daten auf halbem Weg geändert hat. Also, Freunde, Sie können sicher sein, dass die Daten, die Sie erhalten, echt sind und nicht manipuliert wurden.

Warum sollten Sie diese Methode verwenden?

• Datensicherheit: Sicherlich möchten Sie, dass Ihre Daten vor böswilligen Händen sicher sind, oder? Bei der symmetrischen Verschlüsselung werden Ihre Daten verschlüsselt und können nur von der Person geöffnet werden, die den Schlüssel besitzt.
• Datenintegrität: Mit einer Signatur können Sie sicherstellen, dass die Daten, die Sie empfangen oder senden, echt sind und nicht manipuliert wurden. Also, Freunde, ihr müsst euch keine Sorgen machen, dass jemand betrügt.
• Effizienz: Die symmetrische Verschlüsselung ist normalerweise schneller als die asymmetrische Verschlüsselung, da der Ver- und Entschlüsselungsprozess einfacher ist.

Beispiel für die Verwendung in Golang

Jetzt wollen wir sehen, wie man diese Methode in Golang verwendet.

Symmetrische Verschlüsselung in 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)
}

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

Daher ist die standardmäßige symmetrische Verschlüsselungssignaturmethode wichtig für die Aufrechterhaltung der Sicherheit und Integrität Ihrer Daten. Mit der symmetrischen Verschlüsselung können Sie Ihre Daten verschlüsseln, um sie sicher zu machen, und mit einer Signatur können Sie sicherstellen, dass die Daten, die Sie empfangen oder senden, echt sind und nicht manipuliert wurden. Stellen Sie also sicher, dass Freunde diese Methode für alle Arten von Anforderungen verwenden, die eine hohe Sicherheit erfordern.

Quelle:

• HMAC Go
• SHA256

Das obige ist der detaillierte Inhalt vonImplementieren Sie die Methode „Standard Symmetric Encryption Signature“ von Golang. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!