Seguridad de la cadena de suministro de software:
SBOM, firma de artefactos y dependencias
DevSecOps | unfantasmaenelsistema.com
En diciembre de 2020 se supo que unos 18.000 clientes de SolarWinds habían instalado, por su propio canal de actualizaciones y con la firma legítima del fabricante, una puerta trasera. En 2024 se descubrió de casualidad —por unos milisegundos de latencia extra en un login SSH— una puerta trasera incrustada durante dos años en xz/liblzma, una librería de compresión que está en prácticamente toda distribución de Linux. Entre medias, decenas de paquetes maliciosos en npm y PyPI con nombres casi idénticos a los populares. El patrón es siempre el mismo: no atacan tu código, atacan algo en lo que tu código confía.
La cadena de suministro de software es todo lo que entra en tu producto sin que tú lo hayas escrito: dependencias directas y transitivas, imágenes base de contenedor, el compilador, las acciones de CI/CD, el registro del que descargas y el propio mecanismo de actualización. Este artículo recorre esa superficie de ataque y las defensas que hoy son realistas: inventario (SBOM), fijación de versiones, firma y verificación de artefactos, y análisis continuo de vulnerabilidades.
Qué aprenderás en este artículo
Qué partes de tu build son «cadena de suministro» y por qué son un objetivo · Los tipos de ataque reales: typosquatting, confusión de dependencias, mantenedor comprometido, build troyanizado · Qué es un SBOM (CycloneDX, SPDX) y para qué sirve de verdad —y para qué no · Firma y verificación con Sigstore/cosign, procedencia SLSA y npm provenance · Fijar versiones y hashes con lockfiles y –require-hashes, y análisis con osv-scanner y Dependabot
1. La superficie de ataque: dónde se cuela el atacante
Un proyecto moderno de tamaño medio arrastra cientos o miles de paquetes de terceros. La mayoría no los eligió nadie: son dependencias transitivas, es decir, dependencias de tus dependencias. Cada una es código que se ejecuta con los mismos privilegios que el tuyo, y cada una tiene un mantenedor —a veces una sola persona, a veces una cuenta abandonada— cuyo compromiso te afecta directamente.
Pero las dependencias son solo una parte. El atacante también mira el sistema de build (un plugin de Maven o Gradle, un script de postinstall de npm), el pipeline de CI/CD (una GitHub Action referenciada por etiqueta móvil que cambia bajo tus pies, secretos expuestos en logs), el registro (typosquatting, cuentas sin 2FA) y el canal de actualización del producto ya desplegado, que es exactamente lo que se usó en SolarWinds.
| Eslabón | Qué puede comprometer el atacante | Ejemplo real |
|---|---|---|
| Dependencia directa/transitiva | Publicar una versión maliciosa de un paquete legítimo | event-stream (npm, 2018) |
| Registro de paquetes | Subir un paquete con nombre parecido o con prioridad de resolución | Typosquatting en PyPI; dependency confusion (2021) |
| Cuenta de mantenedor | Robo de credenciales o token y publicación firmada como el autor | ua-parser-js, coa, rc (npm, 2021) |
| Sistema de build | Inyectar código en tiempo de compilación, no en el fuente | xz/liblzma (2024); SolarWinds Orion (2020) |
| CI/CD | Action o runner comprometido que altera el artefacto o roba secretos | Codecov bash uploader (2021) |
| Canal de actualización | Distribuir el troyano firmado por el propio fabricante | SolarWinds (2020); NotPetya vía M.E.Doc (2017) |
2. Los ataques, por tipo
2.1 Typosquatting y slopsquatting
El atacante publica un paquete con un nombre a un carácter de distancia de uno popular (python-nmap vs nmap-python, crossenv vs cross-env) y espera a que alguien se equivoque al teclear o copie mal un comando de instalación. La variante moderna, el slopsquatting, aprovecha que los asistentes de IA a veces «alucinan» nombres de paquetes que no existen: el atacante registra esos nombres inventados y espera a que alguien instale lo que la IA le sugirió sin comprobarlo.
2.2 Confusión de dependencias
Muchas empresas tienen paquetes internos (acme-auth, acme-utils) en un registro privado. Si el gestor de paquetes está mal configurado y consulta también el registro público, un atacante que suba un acme-auth al registro público con un número de versión más alto puede conseguir que tu build descargue el suyo en lugar del interno. Alex Birsan demostró esto en 2021 contra decenas de grandes tecnológicas.
2.3 Cuenta de mantenedor comprometida
Phishing al mantenedor, un token de publicación filtrado en un commit, o una cuenta sin 2FA. El atacante publica una versión nueva del paquete real, con su nombre real y su reputación real. Los lockfiles que solo fijan la versión (no el hash) y las políticas de actualización automática propagan el paquete envenenado en horas.
2.4 Build troyanizado
El más difícil de detectar: el código fuente en el repositorio público está limpio. La puerta trasera se inyecta durante la compilación —en xz vivía en unos archivos de test binarios y en un script de ./configure ofuscado que solo se activaba al construir el paquete .deb/.rpm, nunca desde el repositorio git. Por eso auditar solo el fuente no basta: hace falta que el binario sea reproducible y que su origen sea verificable.
3. SBOM: saber qué llevas dentro
Un SBOM (Software Bill of Materials, lista de materiales de software) es el inventario completo de componentes de un artefacto: nombre, versión, identificador único (purl), licencia, hashes y relaciones entre ellos. Los dos formatos estándar son CycloneDX (OWASP) y SPDX (Linux Foundation, norma ISO/IEC 5962). Se genera automáticamente en el pipeline con herramientas como Syft, Trivy, cdxgen o el propio `npm sbom`.
Para qué sirve de verdad: cuando mañana se publica un CVE crítico en una librería, un SBOM guardado te responde en minutos —no en días— a la pregunta «¿está esto en alguno de mis productos, y en qué versión?». Es lo que faltó en muchas organizaciones durante Log4Shell (diciembre de 2021), que pasaron una semana solo averiguando dónde tenían Log4j.
Para qué no sirve: un SBOM no te protege por sí mismo, no dice si una dependencia es explotable en tu contexto (para eso está el análisis VEX, que anota «este CVE no aplica porque no llamamos a esa función») y no vale de nada si se genera y se tira. El valor está en almacenarlo por cada versión publicada y poder consultarlo históricamente.
# Generar un SBOM en formato CycloneDX de una imagen de contenedor syft registry.ejemplo.com/miapp:1.4.2 -o cyclonedx-json > sbom-miapp-1.4.2.json # Generar un SBOM de un proyecto Node y de uno Python npm sbom --sbom-format cyclonedx > sbom.json cyclonedx-py environment -o sbom.json # Cruzar un SBOM ya guardado contra la base de vulnerabilidades OSV osv-scanner scan --sbom sbom-miapp-1.4.2.json
4. Fijar lo que descargas: versiones y hashes
Instalar con rangos abiertos (^1.2.0, >=2.0) significa que dos builds del mismo commit en dos días distintos pueden traer código diferente. La primera capa de defensa es hacer el build determinista.
- Lockfiles: package-lock.json, yarn.lock, poetry.lock, Cargo.lock, go.sum. Fijan la versión exacta de todo el árbol, incluidas las transitivas. Deben estar versionados en git y revisarse en cada PR que los toque.
- Hashes, no solo versiones: pip admite `–require-hashes` con el digest SHA-256 de cada paquete; npm guarda un campo `integrity` en el lockfile; Go usa go.sum. Si el hash no cuadra, el build falla —una versión republicada con el mismo número no cuela.
- Instalación reproducible en CI: usar `npm ci` (no `npm install`), `pip install –require-hashes -r requirements.txt`, `poetry install –sync`. Fallan si el lockfile no está sincronizado, que es justo lo que quieres.
- Fijar GitHub Actions por SHA, no por etiqueta: `uses: actions/checkout@<sha-completo>` en lugar de `@v4`, porque una etiqueta se puede mover a un commit malicioso.
- Fijar imágenes base por digest: `FROM debian:12@sha256:…` en lugar de `FROM debian:12`.
# requirements.txt con hashes: pip rechaza cualquier cosa que no cuadre
requests==2.32.3 \
--hash=sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6
pip install --require-hashes --no-deps -r requirements.txt
# Generar ese fichero con hashes a partir de tu entorno
pip-compile --generate-hashes requirements.in5. Firma y procedencia: de dónde viene este binario
Fijar hashes garantiza que descargas lo mismo que ayer, pero no que ese algo sea legítimo. Para eso hace falta una cadena verificable entre el código fuente, el sistema de build y el artefacto final.
5.1 Sigstore y cosign
Sigstore hace la firma de artefactos sin que el desarrollador gestione claves privadas de larga duración. Usa firma sin clave (keyless): se obtiene un certificado efímero ligado a una identidad OIDC (la cuenta de GitHub Actions, por ejemplo), se firma en esos pocos minutos, y la firma queda registrada en un log público de transparencia (Rekor) que es append-only y auditable, igual que Certificate Transparency para los certificados TLS. `cosign` es la herramienta de línea de comandos.
# Firmar una imagen desde CI (identidad = el propio workflow de GitHub Actions) cosign sign registry.ejemplo.com/miapp:1.4.2 # Verificar antes de desplegar: exige QUIEN firmo y DESDE QUE workflow cosign verify registry.ejemplo.com/miapp:1.4.2 \ --certificate-identity=https://github.com/miorg/miapp/.github/workflows/release.yml@refs/heads/main \ --certificate-oidc-issuer=https://token.actions.githubusercontent.com
5.2 Procedencia SLSA
SLSA (Supply-chain Levels for Software Artifacts) es un marco de niveles que describe cuánta garantía tienes sobre cómo se construyó un artefacto. Su pieza central es la atestación de procedencia: un documento firmado, generado por el propio sistema de build, que dice qué fuente (commit exacto), qué builder y qué parámetros produjeron este binario. Los niveles van de L1 (procedencia existe) a L3 (build aislado y procedencia infalsificable). npm provenance (`npm publish –provenance`) publica esta atestación automáticamente cuando el paquete se construye en un CI compatible, y npmjs.com muestra el enlace al commit y al workflow de origen.
El objetivo práctico: una política de admisión
El destino de todo esto es un control automático en el punto de despliegue —un admission controller de Kubernetes (Sigstore Policy Controller, Kyverno), una regla en el pipeline— que rechace cualquier artefacto sin firma válida y sin procedencia del repositorio y el workflow esperados. Sin ese «portero», firmar es solo ceremonia.
6. Análisis continuo de dependencias
El inventario y la firma no detectan que una de tus 800 dependencias tiene un CVE publicado la semana pasada. Eso lo hace el análisis de composición de software (SCA), que cruza tu árbol de dependencias contra bases de vulnerabilidades.
| Herramienta | Qué hace | Dónde encaja |
|---|---|---|
| osv-scanner | CLI de Google que consulta la base OSV.dev; lee lockfiles y SBOM | Local y en CI, gratis, sin cuenta |
| Dependabot | Alertas + PRs automáticos de actualización en GitHub | Repos en GitHub, configuración mínima |
| Renovate | Como Dependabot pero multiplataforma y muy configurable (agrupado, ventanas) | GitLab, Bitbucket, self-hosted |
| Trivy / Grype | Escáner de imágenes y filesystems; también genera SBOM | Pipeline de contenedores |
| npm audit / pip-audit | Auditoría rápida del ecosistema concreto | Comprobación de andar por casa |
- Ejecuta el escáner en cada PR (que falle el check si entra una vulnerabilidad crítica nueva) y también en cron sobre la rama principal, porque aparecen CVE en código que ya tenías.
- Prioriza con contexto: un CVE crítico en una dependencia de desarrollo que no llega a producción no es lo mismo que uno en una librería expuesta a internet. EPSS y la lista KEV de CISA ayudan a ordenar.
- Vigila la antigüedad y el mantenimiento de las dependencias, no solo los CVE: un paquete sin commits en tres años con un único mantenedor es deuda de seguridad aunque hoy no tenga fallos conocidos.
- Reduce el árbol: cada dependencia que eliminas es superficie que desaparece. Desconfía de las librerías de una sola función.
7. Una hoja de ruta razonable
| Fase | Acción | Esfuerzo |
|---|---|---|
| 1 | Lockfiles versionados + `npm ci` / `pip –require-hashes` en CI | Bajo |
| 2 | SCA (osv-scanner o Dependabot) bloqueando PRs con CVE crítico | Bajo |
| 3 | Generar y archivar un SBOM por cada versión publicada | Medio |
| 4 | Fijar Actions por SHA e imágenes base por digest | Medio |
| 5 | Firma con cosign + npm provenance / atestación SLSA en el release | Medio |
| 6 | Política de admisión que verifica firma y procedencia antes de desplegar | Alto |
| 7 | Registro interno espejo (proxy) para no depender del registro público en cada build | Alto |
Errores frecuentes al implantar esto
Generar SBOM y no guardarlos: el valor es histórico, no del momento · Firmar sin verificar: si nadie comprueba la firma en el despliegue, la firma no aporta seguridad · Fijar por etiqueta creyendo que es fijar (las etiquetas de git y de contenedor son móviles; usa SHA y digest) · Actualización automática sin revisión humana de los cambios en el lockfile en dependencias sensibles · Ignorar el postinstall: los scripts de instalación de npm se ejecutan en tu máquina y en tu CI; considera `–ignore-scripts` y listas de permitidos
Uso responsable y marco legal
Las herramientas y técnicas de este artículo son para auditar y proteger software propio o sobre el que tienes autorización expresa · Publicar paquetes maliciosos, registrar nombres para typosquatting o alterar artefactos de terceros constituye delito —en España, arts. 197 bis, 197 ter, 248 y ss. y 264 del Código Penal, además de la responsabilidad civil correspondiente · Si descubres una dependencia comprometida o un paquete malicioso, sigue divulgación responsable: avisa al mantenedor y al registro (npm security, PyPI, GitHub Security Advisories) y, si procede, al INCIBE-CERT; no lo difundas con pruebas de concepto funcionales antes del parche
Conclusión
La cadena de suministro es la superficie de ataque que menos controlas y más ha crecido: tu producto es, en peso, mayoritariamente código que no escribiste. SolarWinds y xz no fueron accidentes raros, fueron demostraciones de que atacar la confianza escala mucho mejor que atacar el perímetro.
La buena noticia es que las defensas se pueden implantar por capas y las primeras son baratas: lockfiles con hashes, un escáner de dependencias que bloquee lo crítico, y un SBOM archivado por release ya te dejan en mejor posición que la media. Firma, procedencia y política de admisión son el siguiente escalón, y hoy —con Sigstore y las atestaciones SLSA integradas en los CI— están al alcance de cualquier equipo, no solo de las grandes.
Referencias
SLSA — slsa.dev (marco de niveles y plantillas de procedencia) · Sigstore — sigstore.dev · docs de cosign y del log Rekor · OWASP CycloneDX — cyclonedx.org · SPDX — spdx.dev · OSV — osv.dev y osv-scanner (github.com/google/osv-scanner) · CISA/NSA — Securing the Software Supply Chain (guías para desarrolladores y para consumidores) · NIST SSDF (SP 800-218) — prácticas de desarrollo seguro
unfantasmaenelsistema.com | Seguridad, sistemas y todo lo que no debería funcionar (pero funciona)

