Implémentation de la méthode de signature de cryptage symétrique standard avec Golang

Qu'est-ce que la méthode de signature de chiffrement symétrique standard ?

Donc, voyez-vous, cette méthode est un moyen de crypter les données afin qu'elles soient sécurisées et ne puissent pas être lues par des personnes qui n'ont pas la clé de déchiffrement. Imaginez, mes amis, vous avez un journal que vous verrouillez avec un cadenas. Seules les personnes possédant la clé peuvent ouvrir et lire vos agendas.

Chiffrement symétrique

Le cryptage symétrique, c'est comme les amis et les amis, qu'est-ce que c'est, hahaha, le fait est que c'est comme avoir la même clé pour ouvrir la serrure. Cette clé est utilisée pour le cryptage (verrouillage) et le déchiffrement (déverrouillage) des données. Ainsi, amis et amis peuvent verrouiller et déverrouiller les mêmes données tant que vous disposez de la clé.

Signature

La signature ici n'est pas une signature physique, mais plutôt une signature numérique. Cette signature garantit que les données envoyées proviennent véritablement d'amis et que personne n'a modifié les données à mi-chemin. Ainsi, mes amis, vous pouvez être sûr que les données que vous recevez sont authentiques et n'ont pas été falsifiées.

Pourquoi devriez-vous utiliser cette méthode ?

• Sécurité des données : vous souhaitez sûrement que vos données soient à l'abri des mains malveillantes, n'est-ce pas ? Avec le cryptage symétrique, vos données sont cryptées et ne peuvent être ouvertes que par la personne qui possède la clé.
• Intégrité des données : avec une signature, vous pouvez vous assurer que les données que vous recevez ou envoyez sont authentiques et n'ont pas été falsifiées. Alors, mes amis, vous n'avez pas à vous inquiéter que quelqu'un vous trompe.
• Efficacité : le cryptage symétrique est généralement plus rapide que le cryptage asymétrique car le processus de cryptage et de décryptage est plus simple.

Exemple d'utilisation dans Golang

Voyons maintenant comment utiliser cette méthode dans Golang.

Cryptage symétrique dans 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)
}

La méthode de signature de cryptage symétrique standard est donc importante pour maintenir la sécurité et l'intégrité de vos données. Avec le cryptage symétrique, vous pouvez chiffrer vos données pour les sécuriser, et avec une signature, vous pouvez garantir que les données que vous recevez ou envoyez sont authentiques et n'ont pas été falsifiées. Assurez-vous donc que vos amis utilisent cette méthode pour toutes sortes de besoins nécessitant une haute sécurité.

Source :

• HMAC Go
• SHA256

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!