Entropía reproducible en tests de Go: cómo el paquete testing/cryptotest fija el flujo de crypto/randNota · digest del 17 de noviembre
Collage de papel con orden matemático de la entropía y fijación de flujos pseudoaleatorios en Go.
Nota2 secciones≈ 5 min

Entropía reproducible en tests de Go: cómo el paquete testing/cryptotest fija el flujo de crypto/rand

«El paquete cryptotest proporciona una fuente determinista de aleatoriedad para pruebas».

Con esa frase abren los autores de Go la documentación de testing/cryptotest, incorporado en Go 1.27. En cuanto el código recurre al generador crypto/rand, cada ejecución de los tests recibe entropía fresca del sistema: un test que falla en CI pasa limpio en local. ¿Cómo depurar y reproducir entonces un fallo así?

Por qué los tests con crypto/rand se resistían a la depuración

La primera idea es sustituir la fuente de aleatoriedad por tu propio io.Reader con bytes prefijados. Pero en las versiones modernas de crypto/rsa y crypto/ecdsa, la librería estándar exige con más rigor entropía del sistema e ignora directamente los lectores personalizados.

Incluso con un stub dentro de tu código, los algoritmos criptográficos siguen acudiendo al sistema operativo a por aleatoriedad. Un fallo raro de caso límite al generar claves o tokens se convierte en un fantasma imposible de cazar repitiendo la ejecución.

Cómo SetGlobalRandom fija y reinicia el flujo de entropía

En Go 1.27.3, este problema lo resuelve la función SetGlobalRandom de testing/cryptotest:

func SetGlobalRandom(t *testing.T, seed uint64)

El valor seed pasa la fuente global de entropía del proceso a modo determinista: afecta tanto a las llamadas directas a crypto/rand.Read como a todas las fuentes internas de los paquetes crypto/.... El argumento t *testing.T acota la sustitución a la duración del test: cuando termina, el runtime restaura automáticamente el generador del sistema.

La pregunta lógica es: ¿y si dentro del mismo test necesitas ejecutar la generación dos veces y comparar los resultados? Volver a llamar a SetGlobalRandom con la misma semilla reinicia el flujo a su estado inicial.

Me llamó la atención un ejemplo funcional random_test.go del canal Biblioteca del desarrollador Go, verificado sobre Go 1.27.3. El test fija la semilla 42, lee 16 bytes —un tamaño habitual para un token de restablecimiento de contraseña o verificación JWT—, reinicia después el flujo y vuelve a leer 16 bytes:

package mycrypto_test

import (
    "bytes"
    "crypto/rand"
    "testing"
    "testing/cryptotest"
)

func TestDeterministicEntropyStream(t *testing.T) {
    cryptotest.SetGlobalRandom(t, 42)

    firstChunk := make([]byte, 16)
    if _, err := rand.Read(firstChunk); err != nil {
        t.Fatalf("first rand.Read failed: %v", err)
    }

    cryptotest.SetGlobalRandom(t, 42)

    secondChunk := make([]byte, 16)
    if _, err := rand.Read(secondChunk); err != nil {
        t.Fatalf("second rand.Read failed: %v", err)
    }

    if !bytes.Equal(firstChunk, secondChunk) {
        t.Fatal("entropy stream did not reset deterministically")
    }
    t.Logf("deterministic_entropy_verified: len=%d bytes_match=%v", len(firstChunk), bytes.Equal(firstChunk, secondChunk))
}

Fíjate en que el código no tiene ningún array de bytes hardcodeado de antemano. La primera llamada a SetGlobalRandom(t, 42) marca el punto de partida para firstChunk, la segunda reinicia el flujo antes de rellenar secondChunk, y bytes.Equal comprueba que coincidan byte a byte.

Para desactivar la caché de tests de Go y repetir el escenario desde cero, se usa este comando:

go test -v -count=1 ./...

El flag -count=1 limpia la caché, y el registro del test confirma que ambas lecturas de 16 bytes coincidieron bit a bit. Con la semilla capturada ya puedes reproducir en local un fallo de generación de claves o tokens sin reescribir el código con mocks.

Ahora bien, esta sustitución global impone dos restricciones estrictas:

  • Prohibido t.Parallel(): SetGlobalRandom cambia el generador para todo el proceso del sistema operativo, así que ni el propio test ni sus ancestros pueden ejecutarse en paralelo; si lo haces, el test entrará en panic.
  • Modo FIPS-140: al compilar con Go Cryptographic Module v1.0.0 (cuando crypto/fips140.Version devuelve "v1.0.0"), la función no está soportada.

El determinismo en crypto/rand llega exactamente hasta la frontera del paralelismo y del módulo criptográfico certificado.

Si quieres ver más herramientas de fiabilidad en el lenguaje, pásate por nuestro repaso al lanzamiento de Go 1.27 y el análisis sobre fuzzing en Go.

Y la advertencia más importante conviene dejársela a la propia documentación de testing/cryptotest: la forma en que los algoritmos criptográficos consumen la aleatoriedad no está fijada por el estándar y puede cambiar con el tiempo, así que un test que espere una salida concreta de una función criptográfica podría romperse en una versión futura de Go incluso usando SetGlobalRandom.

Quiero un análisis detalladoLos votos ayudan a elegir qué analizar a fondo. Este material tiene 0 votos.
Fuentes · 2