Criptografia em Go (Golang): criptografia e hash

Criptografia em Go (Golang): criptografia e hash de dados

A linguagem Go (Golang) fornece uma biblioteca padrão poderosa e elegante para operações criptográficas. Ao contrário de muitas outras linguagens, onde é necessária a instalação de pacotes de terceiros, Go inclui suporte para criptografia simétrica e assimétrica, bem como algoritmos modernos de hash "prontos para uso". Neste artigo, vamos detalhar como usar criptografia em Go para proteger dados no portal educacional pythonlib.ru.

Principais pacotes de criptografia em Go

Toda a criptografia em Go está concentrada no pacote crypto e seus subpacotes. Aqui estão os principais:

• crypto/aes — implementação do Advanced Encryption Standard (AES).
• crypto/cipher — interfaces para modos de criptografia (CBC, GCM, CTR).
• crypto/rsa — criptografia assimétrica RSA.
• crypto/sha256, crypto/sha512 — funções hash da família SHA-2.
• golang.org/x/crypto/bcrypt — hash adaptativo de senhas (pacote adicional).
• crypto/rand — gerador de números aleatórios criptograficamente seguro.

Criptografia simétrica AES em Go

A criptografia simétrica usa a mesma chave para criptografar e descriptografar. Vamos considerar um exemplo com AES-256 no modo GCM (Galois/Counter Mode), que fornece autenticação de dados.

package main

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

func encryptAES(plaintext []byte, key []byte) ([]byte, error) {    block, err := aes.NewCipher(key)    if err != nil {        return nil, err    }

    // Criando GCM (Galois/Counter Mode)    gcm, err := cipher.NewGCM(block)    if err != nil {        return nil, err    }

    // Gerando um nonce aleatório (número usado uma vez)    nonce := make([]byte, gcm.NonceSize())    if _, err := io.ReadFull(rand.Reader, nonce); err != nil {        return nil, err    }

    // Seal adiciona o nonce ao início do texto cifrado    ciphertext := gcm.Seal(nonce, nonce, plaintext, nil)    return ciphertext, nil}

func decryptAES(ciphertext []byte, key []byte) ([]byte, error) {    block, err := aes.NewCipher(key)    if err != nil {        return nil, err    }

    gcm, err := cipher.NewGCM(block)    if err != nil {        return nil, err    }

    nonceSize := gcm.NonceSize()    if len(ciphertext) < nonceSize {        return nil, fmt.Errorf("ciphertext too short")    }

    nonce, ciphertext := ciphertext[:nonceSize], ciphertext[nonceSize:]    plaintext, err := gcm.Open(nil, nonce, ciphertext, nil)    if err != nil {        return nil, err    }    return plaintext, nil}

func main() {    key := []byte("examplekey123456") // 16 bytes para AES-128    plaintext := []byte("Dados secretos para PythonLib")

    encrypted, _ := encryptAES(plaintext, key)    fmt.Println("Criptografado (hex):", hex.EncodeToString(encrypted))

    decrypted, _ := decryptAES(encrypted, key)    fmt.Println("Descriptografado:", string(decrypted))}

Observe: a chave deve ter 16, 24 ou 32 bytes para AES-128, AES-192 ou AES-256, respectivamente. O nonce (IV) é gerado aleatoriamente e armazenado junto com o texto cifrado.

Criptografia assimétrica RSA em Go

RSA usa um par de chaves: pública (public) para criptografar e privada (private) para descriptografar. Isso é ideal para troca segura de dados entre servidor e cliente.

package main

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

func generateKeyPair(bits int) (*rsa.PrivateKey, error) {