crypto/*, compress & math/rand/v2

Hashing, primitivas de cifrado, compresión y aleatoriedad se encuentran en paquetes enfocados de la biblioteca estándar.

La aleatoriedad sensible a la seguridad proviene de crypto/rand; la simulación y el barajado usan math/rand/v2.

Los paquetes de compresión envuelven io.Reader y io.Writer para que los pipelines de HTTP y archivos permanezcan en streaming.

Resumen

Usa crypto/sha256 y similares para sumas de verificación y direccionamiento de contenido.

Usa crypto/tls y crypto/x509 para listeners HTTPS y TLS mutuo.

Usa compress/gzip para reducir payloads sin cargar archivos completos en memoria.

Trata math/rand/v2 como la API moderna para aleatoriedad no criptográfica con valores Rand explícitos.

Receta

Tarjeta de referencia rápida - lista para copiar y pegar.

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)

Cuándo usar esto:

• Calcular hashes estables para claves de caché o comprobaciones de integridad.
• Generar tokens de sesión, claves API o bytes de nonce.
• Comprimir archivos de registro o respuestas HTTP con gzip.
• Barajar datos de prueba o ejecutar simulaciones con rand/v2 sembrado.

Ejemplo de Trabajo

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

Qué demuestra esto:

• sha256.New como io.Writer para hashing incremental.
• gzip.NewWriter con Close obligatorio para vaciar los tráilers.
• crypto/rand.Read para tokens impredecibles.
• math/rand/v2 con fuente PCG explícita y Shuffle.

Inmersión Profunda

Cómo Funciona

• Las funciones hash implementan hash.Hash (Write, Sum, Reset) para entrada en streaming.
• crypto/rand lee del CSPRNG del sistema operativo (getrandom, /dev/urandom, etc.).
• gzip.Writer comprime en un io.Writer subyacente; los lectores descomprimen simétricamente.
• math/rand/v2 elimina el estado global mutable del diseño del paquete math/rand heredado.

Mapa de Paquetes

Notas de Go

// Compara resúmenes en tiempo constante al proteger secretos:
import "crypto/subtle"
subtle.ConstantTimeCompare(a, b) == 1
 
// Versión mínima de TLS para servidores:
cfg := &tls.Config{MinVersion: tls.VersionTLS12}

Trampas

• Usar math/rand para tokens - La salida predecible permite el secuestro de sesiones. Solución: crypto/rand.Read para secretos; rand/v2 solo para usos no relacionados con la seguridad.
• Olvidar gzip.Writer.Close - La falta del pie de página gzip corrompe la salida comprimida. Solución: siempre Close y verificar el error.
• Reutilizar hash.Hash después de Sum sin Reset - Añade al estado anterior inesperadamente. Solución: llamar a Reset antes de hashear un nuevo payload en la misma instancia.
• Asumir que SHA-256 es cifrado - Los hashes son unidireccionales; no cifran datos confidenciales. Solución: usar crypto/aes o TLS para confidencialidad.
• math/rand global en bibliotecas - Las pruebas se vuelven inestables cuando cambia el orden. Solución: inyectar *rand.Rand de rand/v2 con una semilla explícita en las pruebas.
• Comprimir payloads pequeños - Las cabeceras gzip pueden aumentar cuerpos diminutos. Solución: omitir la compresión por debajo de un umbral de tamaño (a menudo 1-2 KiB).

Alternativas

Preguntas Frecuentes

Relacionado

• os, io, bufio & path/filepath - Introducir datos en hashers en streaming
• database/sql & net Package Family Overview - Listeners y drivers TLS
• log, regexp & text/template - Codificar tokens en logs de forma segura
• Standard Library Best Practices - Reglas de seguridad y dependencias
• net/http Best Practices - TLS y compresión de respuestas

Versiones de Stack: Esta página fue escrita para Go 1.26.x (predeterminado Green Tea GC, go fix modernizers - verificar parche en la compilación), chi (última - verificar en la compilación), gin (última - verificar en la compilación), echo (última - verificar en la compilación), google.golang.org/grpc (última - verificar en la compilación), sigs.k8s.io/controller-runtime (última - verificar en la compilación), kubebuilder (última - verificar en la compilación), tinygo (última - verificar objetivos de placa en la compilación), wazero (última - verificar en la compilación) y golangci-lint (última - verificar conjunto de linters en la compilación).