O AES (Advanced Encryption Standard) representa um algoritmo de criptografia simétrica amplamente utilizado para proteger informações sensíveis. A linguagem Go oferece suporte nativo a essa funcionalidade através do pacote crypto/aes, que geralmente é utilizado em conjunto com o pacote crypto/cipher.

Criação da Chave de Criptografia

Para o algoritmo AES, a chave deve possuir exatamente 16, 24 ou 32 bytes, correspondendo respectivamente às versões AES-128, AES-192 e AES-256.

chave := []byte("32-bytes-minha-chave-segura-1234") // Chave AES-256

Criptografando Dados com CBC

O modo CBC (Cipher Block Chaining) requer o preenchimento (padding) dos dados e a utilização de um vetor de inicialização (IV) aleatório para cada operação de criptografia.

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

func criptografar(dados []byte, chave []byte) ([]byte, error) {
    bloco, erro := aes.NewCipher(chave)
    if erro != nil {
        return nil, erro
    }

    // Aplicar preenchimento PKCS7
    dados = aplicarPadding(dados, aes.BlockSize)

    // Criar IV aleatório
    dadosCriptografados := make([]byte, aes.BlockSize+len(dados))
    vetorIV := dadosCriptografados[:aes.BlockSize]
    if _, erro := io.ReadFull(rand.Reader, vetorIV); erro != nil {
        return nil, erro
    }

    // Executar criptografia
    modoCBC := cipher.NewCBCEncrypter(bloco, vetorIV)
    modoCBC.CryptBlocks(dadosCriptografados[aes.BlockSize:], dados)

    return dadosCriptografados, nil
}

func aplicarPadding(dados []byte, tamanhoBloco int) []byte {
    espacamento := tamanhoBloco - len(dados)%tamanhoBloco
    textoPreenchido := bytes.Repeat([]byte{byte(espacamento)}, espacamento)
    return append(dados, textoPreenchido...)
}

Descriptografando Dados

O processo inverso exige a extração do vetor de inicialização e a remoção do preanchimento aplicado anteriormente.

func descriptografar(dadosCriptografados []byte, chave []byte) ([]byte, error) {
    bloco, erro := aes.NewCipher(chave)
    if erro != nil {
        return nil, erro
    }

    if len(dadosCriptografados) < aes.BlockSize {
        return nil, fmt.Errorf("dados criptografados muito curta")
    }

    vetorIV := dadosCriptografados[:aes.BlockSize]
    dadosCriptografados = dadosCriptografados[aes.BlockSize:]

    // Executar descriptografia
    modoCBC := cipher.NewCBCDecrypter(bloco, vetorIV)
    modoCBC.CryptBlocks(dadosCriptografados, dadosCriptografados)

    // Remover preenchimento
    dadosCriptografados = removerPadding(dadosCriptografados)
    return dadosCriptografados, nil
}

func removerPadding(dados []byte) []byte {
    tamanho := len(dados)
    removimento := int(dados[tamanho-1])
    return dados[:(tamanho - removimento)]
}

Utilizando o Modo GCM (Recomendado)

O modo GCM (Galois/Counter Mode) oferece criptografia autenticada, eliminando a necessidade de gerenciamento manual de preenchimento e proporcionando maior segurança.

func criptografarGCM(dados []byte, chave []byte) ([]byte, error) {
    bloco, erro := aes.NewCipher(chave)
    if erro != nil {
        return nil, erro
    }

    gcm, erro := cipher.NewGCM(bloco)
    if erro != nil {
        return nil, erro
    }

    nonce := make([]byte, gcm.NonceSize())
    if _, erro := io.ReadFull(rand.Reader, nonce); erro != nil {
        return nil, erro
    }

    return gcm.Seal(nonce, nonce, dados, nil), nil
}

func descriptografarGCM(dadosCriptografados []byte, chave []byte) ([]byte, error) {
    bloco, erro := aes.NewCipher(chave)
    if erro != nil {
        return nil, erro
    }

    gcm, erro := cipher.NewGCM(bloco)
    if erro != nil {
        return nil, erro
    }

    tamanhoNonce := gcm.NonceSize()
    if len(dadosCriptografados) < tamanhoNonce {
        return nil, fmt.Errorf("dados criptografados muito cortos")
    }

    nonce, dadosCriptografados := dadosCriptografados[:tamanhoNonce], dadosCriptografados[tamanhoNonce:]
    return gcm.Open(nil, nonce, dadosCriptografados, nil)
}

Recomendações de Segurança

• Gerenciamento de Chaves: As chaves devem ser armazenadas de forma segura, nunca hardcoded no código fonte.
• Vetor de Inicialização: Cada operação de criptografia deve gerar um IV ou nonce aleatório novo, sendo proibido reutilizar esses valores.
• Desempenho: O modo GCM é recomendado para cenários que exigem alto desempenho, enquanto o modo CBC requer tratamento manual de preencihmento.

Essas implementações permitem adicionar funcionalidades de criptografia e descriptografia AES em aplicações Go, podendo escolher entre os modos CBC ou GCM conforme a necessidade específica do projeto.