Qual é o método de assinatura de criptografia simétrica padrão?

Então, veja bem, este método é uma forma de criptografar dados para que sejam seguros e não possam ser lidos por pessoas que não possuem a chave de descriptografia. Imaginem, amigos, vocês têm um diário que trancam com um cadeado. Somente pessoas que possuem a chave podem abrir e ler seus diários.

Criptografia Simétrica

A criptografia simétrica é como amigos e amigos, o que é isso, hahaha, a questão é que é como ter a mesma chave para abrir a fechadura. Esta chave é usada para criptografar (bloquear) e descriptografar (desbloquear) dados. Assim, tanto amigos quanto amigos podem bloquear e desbloquear os mesmos dados, desde que você tenha a chave.

Assinatura

A assinatura aqui não é uma assinatura física, mas sim uma assinatura digital. Essa assinatura garante que os dados enviados são realmente de amigos e que ninguém alterou os dados no meio do caminho. Portanto, amigos, vocês podem ter certeza de que os dados que recebem são genuínos da fonte e não foram adulterados.

Por que você deve usar este método?

• Segurança de dados: Certamente você deseja que seus dados estejam protegidos contra mãos maliciosas, certo? Com a criptografia simétrica, seus dados são criptografados e só podem ser abertos por quem possui a chave.
• Integridade de dados: com uma assinatura, você pode garantir que os dados recebidos ou enviados são genuínos e não foram adulterados. Então, amigos, vocês não precisam se preocupar com a traição de alguém.
• Eficiência: a criptografia simétrica geralmente é mais rápida que a criptografia assimétrica porque o processo de criptografia e descriptografia é mais simples.

Exemplo de uso em Golang

Agora vamos ver como usar esse método em Golang.

Criptografia Simétrica em 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) 




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





 Portanto, o método de assinatura de criptografia simétrica padrão é importante para manter a segurança e integridade de seus dados. Com a criptografia simétrica, você pode criptografar seus dados para torná-los seguros e, com uma assinatura, pode garantir que os dados recebidos ou enviados são genuínos e não foram adulterados. Portanto, certifique-se de que seus amigos usem esse método para todos os tipos de necessidades que exigem alta segurança.

Fonte: 

• HMAC Go
• SHA256