Criptografia em Go: criptografia e hash para iniciantes

Criptografia em Go (Golang): criptografia e hash

Go (Golang) é uma linguagem compilada moderna, conhecida por seu desempenho e suporte integrado a algoritmos criptográficos. A biblioteca padrão crypto fornece tudo o que é necessário para proteger dados: desde hash simples até criptografia assimétrica complexa. Neste artigo, exploraremos as principais ferramentas e mostraremos exemplos práticos de código.

Por que a criptografia é necessária em Go?

A criptografia em Go é usada para:

• Armazenamento de senhas (hash);
• Transmissão de dados pela rede (TLS/SSL);
• Assinaturas digitais e autenticação;
• Criptografia de arquivos confidenciais.

O Go garante segurança por meio de uma API bem projetada — é difícil usar acidentalmente um algoritmo obsoleto ou inseguro.

Hash em Go

Hash é uma transformação unidirecional de dados em uma string de comprimento fixo. Em Go, os pacotes crypto/md5, crypto/sha1, crypto/sha256 e crypto/sha512 são responsáveis por isso.

Exemplo: hash SHA-256

package main

import (    "crypto/sha256"    "fmt")

func main() {    data := []byte("Dados secretos")    hash := sha256.Sum256(data)    fmt.Printf("SHA256: %x", hash)}

Saída: SHA256: 3c3b... (64 caracteres)

Hash com salt para senhas

Para armazenamento seguro de senhas, use crypto/rand para gerar o salt e crypto/sha256:

package main

import (    "crypto/rand"    "crypto/sha256"    "fmt")

func main() {    password := []byte("MinhaSenha123")    salt := make([]byte, 16)    rand.Read(salt)        salted := append(salt, password...)    hash := sha256.Sum256(salted)    fmt.Printf("Salt: %x", salt)    fmt.Printf("Hash: %x", hash)}

Na prática, para senhas, é melhor usar bcrypt (pacote golang.org/x/crypto/bcrypt), mas SHA-256 com salt é uma boa opção para aprendizado.

Criptografia simétrica: AES

AES (Advanced Encryption Standard) é o algoritmo simétrico mais popular. Em Go, é implementado no pacote crypto/aes em conjunto com modos de criptografia (crypto/cipher).

Exemplo: criptografia AES-GCM

package main

import (    "crypto/aes"    "crypto/cipher"    "crypto/rand"    "fmt")

func main() {    key := []byte("0123456789abcdef0123456789abcdef") // 32 bytes para AES-256    plaintext := []byte("Mensagem confidencial")        block, _ := aes.NewCipher(key)    aead, _ := cipher.NewGCM(block)        nonce := make([]byte, aead.NonceSize())    rand.Read(nonce)        ciphertext := aead.Seal(nil, nonce, plaintext, nil)    fmt.Printf("Criptografado: %x", ciphertext)        // Descriptografia    decrypted, _ := aead.Open(nil, nonce, ciphertext, nil)    fmt.Printf("Descriptografado: %s", decrypted)}

GCM (Galois/Counter Mode) fornece confidencialidade e autenticação — a melhor escolha para a maioria das tarefas.

Criptografia assimétrica: RSA

RSA usa um par de chaves (pública e privada). Em Go, é implementado em crypto/rsa e crypto/rand.

Geração de chaves e criptografia

package main

import (    "crypto/rand"    "crypto/rsa"    "crypto/sha256"    "fmt")

func main() {    privateKey, _ := rsa.GenerateKey(rand.Reader, 2048)    publicKey := &privateKey.PublicKey        message := []byte("Segredo para RSA")    label := []byte("")        // Criptografia com chave pública    ciphertext, _ := rsa.EncryptOAEP(sha256.New(), rand.Reader, publicKey, message, label)    fmt.Printf("Criptografado com RSA: %x", ciphertext)        // Descriptografia com chave privada    plaintext, _ := rsa.DecryptOAEP(sha