crypto/*, compress & math/rand/v2

Hashing, primitivas de criptografia, compressão e aleatoriedade residem em pacotes focados da biblioteca padrão.

A aleatoriedade sensível à segurança vem de crypto/rand; simulação e embaralhamento usam math/rand/v2.

Pacotes de compressão envolvem io.Reader e io.Writer para que pipelines HTTP e de arquivos permaneçam em streaming.

Resumo

Use crypto/sha256 e similares para checksums e endereçamento de conteúdo.

Use crypto/tls e crypto/x509 para listeners HTTPS e TLS mútuo.

Use compress/gzip para encolher payloads sem carregar arquivos inteiros na memória.

Trate math/rand/v2 como a API moderna para aleatoriedade não criptográfica com valores Rand explícitos.

Receita

Cartão de referência rápida - pronto para copiar e colar.

import (
    "crypto/rand"
    "crypto/sha256"
    "encoding/hex"
    "io"
)
 
h := sha256.New()
_, _ = io.Copy(h, reader)
sum := hex.EncodeToString(h.Sum(nil))
 
token := make([]byte, 32)
_, _ = rand.Read(token)

Quando usar:

• Computar hashes estáveis para chaves de cache ou verificações de integridade.
• Gerar tokens de sessão, chaves de API ou bytes de nonce.
• Comprimir arquivos de log ou respostas HTTP com gzip.
• Embaralhar fixtures de teste ou executar simulações com rand/v2 semeado.

Exemplo de Trabalho

package main
 
import (
    "bytes"
    "compress/gzip"
    "crypto/rand"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "io"
    "math/rand/v2"
)
 
func hashAndCompress(in []byte) (digest string, compressed []byte, err error) {
    h := sha256.New()
    if _, err = h.Write(in); err != nil {
        return "", nil, err
    }
    digest = hex.EncodeToString(h.Sum(nil))
 
    var buf bytes.Buffer
    zw := gzip.NewWriter(&buf)
    if _, err = zw.Write(in); err != nil {
        zw.Close()
        return "", nil, err
    }
    if err = zw.Close(); err != nil {
        return "", nil, err
    }
    return digest, buf.Bytes(), nil
}
 
func secureToken(n int) (string, error) {
    b := make([]byte, n)
    if _, err := rand.Read(b); err != nil {
        return "", err
    }
    return hex.EncodeToString(b), nil
}
 
func shuffleDemo(seed uint64, items []string) []string {
    r := rand.New(rand.NewPCG(seed, seed^0x9e3779b97f4a7c15))
    out := append([]string(nil), items...)
    r.Shuffle(len(out), func(i, j int) { out[i], out[j] = out[j], out[i] })
    return out
}
 
func main() {
    payload := []byte("hello stdlib")
    digest, gz, err := hashAndCompress(payload)
    if err != nil {
        panic(err)
    }
    fmt.Println("sha256:", digest)
    fmt.Println("gzip bytes:", len(gz))
 
    tok, err := secureToken(16)
    if err != nil {
        panic(err)
    }
    fmt.Println("token:", tok)
 
    fmt.Println(shuffleDemo(42, []string{"a", "b", "c", "d"}))
}

O que isso demonstra:

• sha256.New como io.Writer para hashing incremental.
• gzip.NewWriter com Close obrigatório para descarregar trailers.
• crypto/rand.Read para tokens imprevisíveis.
• math/rand/v2 com fonte PCG explícita e Shuffle.

Mergulho Profundo

Como Funciona

• Funções de hash implementam hash.Hash (Write, Sum, Reset) para entrada em streaming.
• crypto/rand lê do CSPRNG do sistema operacional (getrandom, /dev/urandom, etc.).
• gzip.Writer comprime em um io.Writer subjacente; leitores descomprimem simetricamente.
• math/rand/v2 remove o estado mutável global do design do pacote legado math/rand.

Mapa de Pacotes

Notas Go

// Compare digests em tempo constante ao proteger segredos:
import "crypto/subtle"
subtle.ConstantTimeCompare(a, b) == 1
 
// Versão mínima TLS para servidores:
cfg := &tls.Config{MinVersion: tls.VersionTLS12}

Armadilhas

• Usar math/rand para tokens - Saída previsível permite sequestro de sessão. Correção: crypto/rand.Read para segredos; rand/v2 apenas para usos não relacionados à segurança.
• Esquecer gzip.Writer.Close - Falta do rodapé gzip corrompe a saída comprimida. Correção: sempre chame Close e verifique o erro.
• Reutilizar hash.Hash após Sum sem Reset - Acrescenta ao estado anterior inesperadamente. Correção: chame Reset antes de fazer hash de um novo payload na mesma instância.
• Assumir que SHA-256 é criptografia - Hashes são de mão única; eles não criptografam dados confidenciais. Correção: use crypto/aes ou TLS para confidencialidade.
• math/rand global em bibliotecas - Testes se tornam instáveis quando a ordem muda. Correção: injete *rand.Rand de rand/v2 com semente explícita nos testes.
• Comprimir payloads pequenos - Cabeçalhos Gzip podem aumentar corpos minúsculos. Correção: pule a compressão abaixo de um limite de tamanho (geralmente 1-2 KiB).

Alternativas

FAQs

Relacionados

• os, io, bufio & path/filepath - Inserindo dados em hashers via streaming
• database/sql & net Package Family Overview - Listeners e drivers TLS
• log, regexp & text/template - Codificando tokens em logs com segurança
• Standard Library Best Practices - Regras de segurança e dependência
• net/http Best Practices - TLS e compressão de resposta

Versões da Stack: Esta página foi escrita para Go 1.26.x (padrão GC Green Tea, go fix modernizers - verifique o patch na compilação), chi (última versão - verifique na compilação), gin (última versão - verifique na compilação), echo (última versão - verifique na compilação), google.golang.org/grpc (última versão - verifique na compilação), sigs.k8s.io/controller-runtime (última versão - verifique na compilação), kubebuilder (última versão - verifique na compilação), tinygo (última versão - verifique os alvos de placa na compilação), wazero (última versão - verifique na compilação) e golangci-lint (última versão - verifique o conjunto de linters na compilação).