«El paquete
cryptotestproporciona 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():SetGlobalRandomcambia 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.Versiondevuelve"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.

